
import torch
from torch import nn
class  lowercase__(				nn.Module							):



	"""simple docstring"""




	def __init__(       self  :			Union[str, Any]       ,							SCREAMING_SNAKE_CASE_  :			List[Any]       ,							SCREAMING_SNAKE_CASE_  :			str       ,							SCREAMING_SNAKE_CASE_  :			List[str]       ,							SCREAMING_SNAKE_CASE_  :			Tuple       ,							SCREAMING_SNAKE_CASE_  :			Union[str, Any]=1       ,							SCREAMING_SNAKE_CASE_  :			Optional[int]=False       )       ->     Any:
					super().__init__()

					lowercase_       =					n_token
					lowercase_       =					d_embed
					lowercase_       =					d_proj

					lowercase_       =					cutoffs + [n_token]
					lowercase_       =					[0] + self.cutoffs
					lowercase_       =					div_val

					lowercase_       =					self.cutoffs[0]
					lowercase_       =					len(self.cutoffs       ) - 1
					lowercase_       =					self.shortlist_size + self.n_clusters

					if self.n_clusters > 0:
									lowercase_       =					nn.Parameter(torch.zeros(self.n_clusters       ,							self.d_embed       )       )
									lowercase_       =					nn.Parameter(torch.zeros(self.n_clusters       )       )

					lowercase_       =					nn.ModuleList()
					lowercase_       =					nn.ParameterList()

					if div_val == 1:
									for i in range(len(self.cutoffs       )       ):
													if d_proj != d_embed:
																	self.out_projs.append(nn.Parameter(torch.FloatTensor(SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       )       )       )
													else:
																	self.out_projs.append(SCREAMING_SNAKE_CASE_       )

									self.out_layers.append(nn.Linear(SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       )       )
					else:
									for i in range(len(self.cutoffs       )       ):
													lowercase_  ,	lowercase_       =					self.cutoff_ends[i], self.cutoff_ends[i + 1]
													lowercase_       =					d_embed // (div_val**i)

													self.out_projs.append(nn.Parameter(torch.FloatTensor(SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       )       )       )

													self.out_layers.append(nn.Linear(SCREAMING_SNAKE_CASE_       ,							r_idx - l_idx       )       )

					lowercase_       =					keep_order
	def 						_lowercase  (       self  :			Optional[int]       ,							SCREAMING_SNAKE_CASE_  :			int       ,							SCREAMING_SNAKE_CASE_  :			List[str]       ,							SCREAMING_SNAKE_CASE_  :			List[Any]       ,							SCREAMING_SNAKE_CASE_  :			Union[str, Any]       )       ->     Tuple:
					if proj is None:
									lowercase_       =					nn.functional.linear(SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       ,							bias=SCREAMING_SNAKE_CASE_       )
					else:
									# if CUDA_MAJOR <= 9 and CUDA_MINOR <= 1:
									lowercase_       =					nn.functional.linear(SCREAMING_SNAKE_CASE_       ,							proj.t().contiguous()       )
									lowercase_       =					nn.functional.linear(SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       ,							bias=SCREAMING_SNAKE_CASE_       )
									# else:
									#     logit = torch.einsum('bd,de,ev->bv', (hidden, proj, weight.t()))
									#     if bias is not None:
									#         logit = logit + bias

					return logit
	def 						_lowercase  (       self  :			Dict       ,							SCREAMING_SNAKE_CASE_  :			Any       ,							SCREAMING_SNAKE_CASE_  :			List[str]=None       ,							SCREAMING_SNAKE_CASE_  :			Optional[Any]=False       )       ->     Optional[Any]:

					if labels is not None:
									# Shift so that tokens < n predict n
									lowercase_       =					hidden[..., :-1, :].contiguous()
									lowercase_       =					labels[..., 1:].contiguous()
									lowercase_       =					hidden.view(-1       ,							hidden.size(-1       )       )
									lowercase_       =					labels.view(-1       )
									if hidden.size(0       ) != labels.size(0       ):
													raise RuntimeError('''Input and labels should have the same size in the batch dimension.'''       )
					else:
									lowercase_       =					hidden.view(-1       ,							hidden.size(-1       )       )

					if self.n_clusters == 0:
									lowercase_       =					self._compute_logit(SCREAMING_SNAKE_CASE_       ,							self.out_layers[0].weight       ,							self.out_layers[0].bias       ,							self.out_projs[0]       )
									if labels is not None:
													lowercase_       =					labels != -1_0_0
													lowercase_       =					torch.zeros_like(SCREAMING_SNAKE_CASE_       ,							dtype=hidden.dtype       ,							device=hidden.device       )
													lowercase_       =					(
													    -nn.functional.log_softmax(SCREAMING_SNAKE_CASE_       ,							dim=-1       )[mask].gather(1       ,							labels[mask].unsqueeze(1       )       ).squeeze(1       )
													)
									else:
													lowercase_       =					nn.functional.log_softmax(SCREAMING_SNAKE_CASE_       ,							dim=-1       )
					else:
									# construct weights and biases
									lowercase_  ,	lowercase_       =					[], []
									for i in range(len(self.cutoffs       )       ):
													if self.div_val == 1:
																	lowercase_  ,	lowercase_       =					self.cutoff_ends[i], self.cutoff_ends[i + 1]
																	lowercase_       =					self.out_layers[0].weight[l_idx:r_idx]
																	lowercase_       =					self.out_layers[0].bias[l_idx:r_idx]
													else:
																	lowercase_       =					self.out_layers[i].weight
																	lowercase_       =					self.out_layers[i].bias

													if i == 0:
																	lowercase_       =					torch.cat([weight_i, self.cluster_weight]       ,							dim=0       )
																	lowercase_       =					torch.cat([bias_i, self.cluster_bias]       ,							dim=0       )

													weights.append(SCREAMING_SNAKE_CASE_       )
													biases.append(SCREAMING_SNAKE_CASE_       )

									lowercase_  ,	lowercase_  ,	lowercase_       =					weights[0], biases[0], self.out_projs[0]

									lowercase_       =					self._compute_logit(SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       )
									lowercase_       =					nn.functional.log_softmax(SCREAMING_SNAKE_CASE_       ,							dim=1       )

									if labels is None:
													lowercase_       =					hidden.new_empty((head_logit.size(0       ), self.n_token)       )
									else:
													lowercase_       =					torch.zeros_like(SCREAMING_SNAKE_CASE_       ,							dtype=hidden.dtype       ,							device=hidden.device       )

									lowercase_       =					0
									lowercase_       =					[0] + self.cutoffs
									for i in range(len(SCREAMING_SNAKE_CASE_       ) - 1       ):
													lowercase_  ,	lowercase_       =					cutoff_values[i], cutoff_values[i + 1]

													if labels is not None:
																	lowercase_       =					(labels >= l_idx) & (labels < r_idx)
																	lowercase_       =					mask_i.nonzero().squeeze()

																	if indices_i.numel() == 0:
																					continue

																	lowercase_       =					labels.index_select(0       ,							SCREAMING_SNAKE_CASE_       ) - l_idx
																	lowercase_       =					head_logprob.index_select(0       ,							SCREAMING_SNAKE_CASE_       )
																	lowercase_       =					hidden.index_select(0       ,							SCREAMING_SNAKE_CASE_       )
													else:
																	lowercase_       =					hidden

													if i == 0:
																	if labels is not None:
																					lowercase_       =					head_logprob_i.gather(1       ,							target_i[:, None]       ).squeeze(1       )
																	else:
																					lowercase_       =					head_logprob[:, : self.cutoffs[0]]
													else:
																	lowercase_  ,	lowercase_  ,	lowercase_       =					weights[i], biases[i], self.out_projs[i]

																	lowercase_       =					self._compute_logit(SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       )
																	lowercase_       =					nn.functional.log_softmax(SCREAMING_SNAKE_CASE_       ,							dim=1       )
																	lowercase_       =					self.cutoffs[0] + i - 1  # No probability for the head cluster
																	if labels is not None:
																					lowercase_       =					head_logprob_i[:, cluster_prob_idx] + tail_logprob_i.gather(
																					    1       ,							target_i[:, None]       ).squeeze(1       )
																	else:
																					lowercase_       =					head_logprob[:, cluster_prob_idx, None] + tail_logprob_i
																					lowercase_       =					logprob_i

													if labels is not None:
																	if (hasattr(self       ,							'''keep_order'''       ) and self.keep_order) or keep_order:
																					out.index_copy_(0       ,							SCREAMING_SNAKE_CASE_       ,							-logprob_i       )
																	else:
																					out[offset : offset + logprob_i.size(0       )].copy_(-logprob_i       )
																	offset += logprob_i.size(0       )

					return out




	def 						_lowercase  (       self  :			Union[str, Any]       ,							SCREAMING_SNAKE_CASE_  :			List[Any]       )       ->     Optional[int]:
					if self.n_clusters == 0:
									lowercase_       =					self._compute_logit(SCREAMING_SNAKE_CASE_       ,							self.out_layers[0].weight       ,							self.out_layers[0].bias       ,							self.out_projs[0]       )
									return nn.functional.log_softmax(SCREAMING_SNAKE_CASE_       ,							dim=-1       )
					else:
									# construct weights and biases
									lowercase_  ,	lowercase_       =					[], []
									for i in range(len(self.cutoffs       )       ):
													if self.div_val == 1:
																	lowercase_  ,	lowercase_       =					self.cutoff_ends[i], self.cutoff_ends[i + 1]
																	lowercase_       =					self.out_layers[0].weight[l_idx:r_idx]
																	lowercase_       =					self.out_layers[0].bias[l_idx:r_idx]
													else:
																	lowercase_       =					self.out_layers[i].weight
																	lowercase_       =					self.out_layers[i].bias

													if i == 0:
																	lowercase_       =					torch.cat([weight_i, self.cluster_weight]       ,							dim=0       )
																	lowercase_       =					torch.cat([bias_i, self.cluster_bias]       ,							dim=0       )

													weights.append(SCREAMING_SNAKE_CASE_       )
													biases.append(SCREAMING_SNAKE_CASE_       )

									lowercase_  ,	lowercase_  ,	lowercase_       =					weights[0], biases[0], self.out_projs[0]
									lowercase_       =					self._compute_logit(SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       )

									lowercase_       =					hidden.new_empty((head_logit.size(0       ), self.n_token)       )
									lowercase_       =					nn.functional.log_softmax(SCREAMING_SNAKE_CASE_       ,							dim=1       )

									lowercase_       =					[0] + self.cutoffs
									for i in range(len(SCREAMING_SNAKE_CASE_       ) - 1       ):
													lowercase_  ,	lowercase_       =					cutoff_values[i], cutoff_values[i + 1]

													if i == 0:
																	lowercase_       =					head_logprob[:, : self.cutoffs[0]]
													else:
																	lowercase_  ,	lowercase_  ,	lowercase_       =					weights[i], biases[i], self.out_projs[i]

																	lowercase_       =					self._compute_logit(SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       ,							SCREAMING_SNAKE_CASE_       )
																	lowercase_       =					nn.functional.log_softmax(SCREAMING_SNAKE_CASE_       ,							dim=1       )

																	lowercase_       =					head_logprob[:, -i] + tail_logprob_i
																	lowercase_       =					logprob_i

									return out












"""simple docstring"""




def 			lowerCAmelCase__     (     UpperCamelCase__     ,   UpperCamelCase__				):



  '''simple docstring'''

  # Check if the input is valid
  if not len(UpperCamelCase__				) == len(UpperCamelCase__				) == 3:
    raise ValueError("""Please enter a valid equation."""				)
  if equationa[0] == equationa[1] == equationa[0] == equationa[1] == 0:
    raise ValueError("""Both a & b of two equations can't be zero."""				)

  # Extract the coefficients
  _a      ,  _a      ,  _a  :       Any             =	equationa
  _a      ,  _a      ,  _a  :       Tuple             =	equationa

  # Calculate the determinants of the matrices
  _a  :       int             =	aa * ba - aa * ba
  _a  :       str             =	ca * ba - ca * ba
  _a  :       str             =	aa * ca - aa * ca

  # Check if the system of linear equations has a solution (using Cramer's rule)
  if determinant == 0:
    if determinant_x == determinant_y == 0:
      raise ValueError("""Infinite solutions. (Consistent system)"""				)
    else:
      raise ValueError("""No solution. (Inconsistent system)"""				)
  else:
    if determinant_x == determinant_y == 0:
      # Trivial solution (Inconsistent system)
      return (0.0, 0.0)
    else:
      _a  :       Dict             =	determinant_x / determinant
      _a  :       str             =	determinant_y / determinant
      # Non-Trivial Solution (Consistent system)
      return (x, y)

