__init__(self, compute, basis, name=None, logger=None, selection_rules=None, selection_rule_steps=None, memory_constrained=False): 

• compute: callable | Operator

  the function that turns indices into values

• basis: RepresentationBasis

  the basis quanta used in the representations

• logger: None | Logger

  logger for printing out debug info

@property
parallelizer(self): 

compute(self, inds, **kwargs): 

compute_cached(self, inds): 

@property
chunk_size(self): 

clear_cache(self): 

@property
diag(self): 

@property
ndims(self): 

@property
dim_inds(self): 

get_brakets(self, states, check_orthogonality=True, memory_constrained=False): 

Computes term elements based on getting a BraKetSpace. Can directly pass element specs through, since the shape management shit is managed by the BraKetSpace

• states: BraKetSpace | Tuple[np.ndarray, np.ndarray]

• :returns: _

get_element(self, n, m): 

Computes term elements. Determines first whether it needs to pull single elements or blocks of them.

• n: Any

• m: Any

• :returns: _

__getitem__(self, item): 

__rmul__(self, other): 

__mul__(self, other): 

__add__(self, other): 

__repr__(self): 

@property
selection_rules(self): 

• :returns: _

@property
selection_rule_steps(self): 

• :returns: _

@property
is_diagonal(self): 

@property
is_zero(self): 

@property
skipped_indices(self): 

• :returns: _

get_transformed_space(self, space, parallelizer=None, logger=None, **opts): 

Returns the state space obtained by using the held operator to transform space

• space: Any

• :returns: SelectionRuleStateSpace

  c o n n e c t e d

s t a t e

s p a c e s

apply(self, other): 

get_representation_matrix(self, coupled_space, total_space, filter_space=None, diagonal=False, logger=None, zero_element_warning=True, clear_sparse_caches=True, clear_operator_caches=True, assume_symmetric=True, remove_duplicates=True, memory_constrained=None): 

Actively constructs a perturbation theory Hamiltonian representation

• h: Any

• cs: Any

• :returns: _

get_diagonal_representation(self, coupled_space, total_space, logger=None, zero_element_warning=True, clear_sparse_caches=True): 

Actively constructs a perturbation theory Hamiltonian representation

• h: Any

• cs: Any

• :returns: _