




from typing import Dict, Optional, Tuple

import torch
def 		a_       (   __lowerCAmelCase							):
  lowerCAmelCase__								=			boundaries[1] - boundaries[0]
  lowerCAmelCase__								=			boundaries + step / 2
  lowerCAmelCase__								=			torch.cat([bin_centers, (bin_centers[-1] + step).unsqueeze(-1							)]      ,   dim=0							)
  return bin_centers
def 		a_       (   __lowerCAmelCase      ,   __lowerCAmelCase      ,   ):
  lowerCAmelCase__								=			_calculate_bin_centers(__lowerCAmelCase							)
  return (
      torch.sum(aligned_distance_error_probs * bin_centers      ,   dim=-1							),
      bin_centers[-1],
  )
def 		a_       (   __lowerCAmelCase      ,   __lowerCAmelCase = 31      ,   __lowerCAmelCase = 64      ,   **__lowerCAmelCase      ,   ):
  lowerCAmelCase__								=			torch.linspace(0      ,   __lowerCAmelCase      ,   steps=(no_bins - 1)      ,   device=logits.device							)

  lowerCAmelCase__								=			torch.nn.functional.softmax(__lowerCAmelCase      ,   dim=-1							)
  lowerCAmelCase__							,			lowerCAmelCase__								=			_calculate_expected_aligned_error(
      alignment_confidence_breaks=__lowerCAmelCase      ,   aligned_distance_error_probs=__lowerCAmelCase      ,   )

  return {
      "aligned_confidence_probs": aligned_confidence_probs,
      "predicted_aligned_error": predicted_aligned_error,
      "max_predicted_aligned_error": max_predicted_aligned_error,
  }




def 		a_       (   __lowerCAmelCase      ,   __lowerCAmelCase = None      ,   __lowerCAmelCase = 31      ,   __lowerCAmelCase = 64      ,   __lowerCAmelCase = 1E-8      ,   **__lowerCAmelCase      ,   ):
  if residue_weights is None:
    lowerCAmelCase__								=			logits.new_ones(logits.shape[-2]							)

  lowerCAmelCase__								=			torch.linspace(0      ,   __lowerCAmelCase      ,   steps=(no_bins - 1)      ,   device=logits.device							)

  lowerCAmelCase__								=			_calculate_bin_centers(__lowerCAmelCase							)
  torch.sum(__lowerCAmelCase							)
  lowerCAmelCase__								=			logits.shape[-2]
  lowerCAmelCase__								=			max(__lowerCAmelCase      ,   19							)

  lowerCAmelCase__								=			1.24 * (clipped_n - 15) ** (1.0 / 3) - 1.8

  lowerCAmelCase__								=			torch.nn.functional.softmax(__lowerCAmelCase      ,   dim=-1							)

  lowerCAmelCase__								=			1.0 / (1 + (bin_centers**2) / (da**2))
  lowerCAmelCase__								=			torch.sum(probs * tm_per_bin      ,   dim=-1							)

  lowerCAmelCase__								=			residue_weights / (eps + residue_weights.sum())
  lowerCAmelCase__								=			torch.sum(predicted_tm_term * normed_residue_mask      ,   dim=-1							)

  lowerCAmelCase__								=			per_alignment * residue_weights

  lowerCAmelCase__								=			(weighted == torch.max(__lowerCAmelCase							)).nonzero()[0]
  return per_alignment[tuple(__lowerCAmelCase							)]







from __future__ import annotations

from collections.abc import Iterator
from typing import Any





class 						SCREAMING_SNAKE_CASE__		:
     def __init__(	self  :		int					,	__lowerCamelCase  :		Any	):



       """simple docstring"""
       lowerCAmelCase__								=			data
       lowerCAmelCase__								=			None



     def __str__(	self  :		int	):



       """simple docstring"""
       return F"""{self.data}"""





class 						SCREAMING_SNAKE_CASE__		:
     def __init__(	self  :		Union[str, Any]	):



       """simple docstring"""
       lowerCAmelCase__								=			None
       lowerCAmelCase__								=			None
     def __iter__(	self  :		List[Any]	):



       """simple docstring"""
       lowerCAmelCase__								=			self.front
       while node:
         yield node.data
         lowerCAmelCase__								=			node.next
     def __len__(	self  :		int	):



       """simple docstring"""
       return len(tuple(iter(self	)	)	)
     def __str__(	self  :		Optional[int]	):



       """simple docstring"""
       return " <- ".join(str(__lowerCamelCase	) for item in self	)
     def 					A__			(	self  :		Tuple	):



       """simple docstring"""
       return len(self	) == 0
     def 					A__			(	self  :		str					,	__lowerCamelCase  :		Any	):



       """simple docstring"""
       lowerCAmelCase__								=			Node(__lowerCamelCase	)
       if self.is_empty():
         lowerCAmelCase__								=			lowerCAmelCase__								=			node
       else:
         assert isinstance(self.rear					,	__lowerCamelCase	)
         lowerCAmelCase__								=			node
         lowerCAmelCase__								=			node
     def 					A__			(	self  :		Optional[Any]	):



       """simple docstring"""
       if self.is_empty():
         raise IndexError('''dequeue from empty queue'''	)
       assert isinstance(self.front					,	__lowerCamelCase	)
       lowerCAmelCase__								=			self.front
       lowerCAmelCase__								=			self.front.next
       if self.front is None:
         lowerCAmelCase__								=			None
       return node.data



     def 					A__			(	self  :		Tuple	):



       """simple docstring"""
       lowerCAmelCase__								=			lowerCAmelCase__								=			None


if __name__ == "__main__":
      from doctest import testmod

      testmod()

