def __setitem__(self, key, value): assert isinstance(key, tuple) assert len(key) == 2 key_is_tuple_of_slices = all([isinstance(key_i, slice) for key_i in key]) key_is_tuple_of_slice_and_int = isinstance(key[0], slice) and isinstance(key[1], int) key_is_tuple_of_int_and_slice = isinstance(key[0], int) and isinstance(key[1], slice) key_is_tuple_of_int = all([isinstance(key_i, int) for key_i in key]) if key_is_tuple_of_slices: # matrix[:5, :5] converted_key = wrapping.Slicer( *slice_to_array(self, key, self._component_name_to_basis_component_length, self._component_name_to_basis_component_index)) if isinstance(value, type(self)): value = value.content self.content[converted_key] = value elif key_is_tuple_of_slice_and_int: # matrix[:5, 5] converted_key_0 = wrapping.Slicer( slice_to_array(self, key[0], self._component_name_to_basis_component_length[0], self._component_name_to_basis_component_index[0])) converted_key = (converted_key_0, key[1]) if isinstance(value, backend.Vector.Type()): value = value.content self.content[converted_key] = value elif key_is_tuple_of_int_and_slice: # matrix[5, :5] converted_key_1 = wrapping.Slicer( slice_to_array(self, key[1], self._component_name_to_basis_component_length[1], self._component_name_to_basis_component_index[1])) converted_key = (key[0], converted_key_1) if isinstance(value, backend.Vector.Type()): value = value.content self.content[converted_key] = value elif key_is_tuple_of_int: # matrix[5, 5] self.content[key] = value else: raise TypeError("Unsupported key type in Matrix.__setitem__")
def _prepare_trivial_precomputed_slice(self): empty_slice = slice(None) assert self._type in ("error_estimation_operators_11", "error_estimation_operators_21", "error_estimation_operators_22", "operators") if self._type == "error_estimation_operators_11": pass # nothing to be done (scalar content) elif self._type == "error_estimation_operators_21": assert "delayed_functions" in self._content assert len(self._content["delayed_functions"]) is 2 assert "delayed_functions_shape" in self._content slice_ = slice_to_array(self._content["delayed_functions_shape"], empty_slice, self._content["delayed_functions_shape"]._component_name_to_basis_component_length, self._content["delayed_functions_shape"]._component_name_to_basis_component_index) self._precomputed_slices[slice_] = self elif self._type == "error_estimation_operators_22": assert "delayed_functions" in self._content assert len(self._content["delayed_functions"]) is 2 assert "delayed_functions_shape" in self._content slice_ = slice_to_array(self._content["delayed_functions_shape"], (empty_slice, empty_slice), self._content["delayed_functions_shape"]._component_name_to_basis_component_length, self._content["delayed_functions_shape"]._component_name_to_basis_component_index) self._precomputed_slices[slice_] = self elif self._type == "operators": assert len(self._content["basis_functions"]) in (0, 1, 2) assert "basis_functions_shape" in self._content if len(self._content["basis_functions"]) is 0: pass # nothing to be done (scalar content) elif len(self._content["basis_functions"]) is 1: slice_ = slice_to_array(self._content["basis_functions_shape"], empty_slice, self._content["basis_functions_shape"]._component_name_to_basis_component_length, self._content["basis_functions_shape"]._component_name_to_basis_component_index) self._precomputed_slices[slice_] = self elif len(self._content["basis_functions"]) is 2: slices = slice_to_array(self._content["basis_functions_shape"], (empty_slice, empty_slice), self._content["basis_functions_shape"]._component_name_to_basis_component_length, self._content["basis_functions_shape"]._component_name_to_basis_component_index) self._precomputed_slices[slices] = self else: raise ValueError("Invalid length") else: raise ValueError("Invalid type")
def __getitem__(self, key): assert self._type in ("error_estimation_operators_22", "operators") if self._type == "error_estimation_operators_22": assert len(key) is 2 assert "delayed_functions" in self._content assert len(self._content["delayed_functions"]) is 2 assert "delayed_functions_shape" in self._content slice_ = slice_to_array(self._content["delayed_functions_shape"], key, self._content["delayed_functions_shape"]._component_name_to_basis_component_length, self._content["delayed_functions_shape"]._component_name_to_basis_component_index) if slice_ in self._precomputed_slices: return self._precomputed_slices[slice_] else: output = NonAffineExpansionStorage.__new__(type(self), *self._shape) output.__init__(*self._shape) output._type = self._type output._content["inner_product_matrix"] = self._content["inner_product_matrix"] output._content["delayed_functions"] = [NonAffineExpansionStorageContent_Base(self._shape[0], dtype=object), NonAffineExpansionStorageContent_Base(self._shape[1], dtype=object)] for q in range(self._shape[0]): output._content["delayed_functions"][0][q] = self._content["delayed_functions"][0][q][key[0]] for q in range(self._shape[1]): output._content["delayed_functions"][1][q] = self._content["delayed_functions"][1][q][key[1]] output._content["delayed_functions_shape"] = DelayedTransposeShape((output._content["delayed_functions"][0][0], output._content["delayed_functions"][1][0])) self._precomputed_slices[slice_] = output return output elif self._type == "operators": assert len(key) is 2 assert "basis_functions" in self._content assert len(self._content["basis_functions"]) is 2 assert "basis_functions_shape" in self._content slices = slice_to_array(self._content["basis_functions_shape"], key, self._content["basis_functions_shape"]._component_name_to_basis_component_length, self._content["basis_functions_shape"]._component_name_to_basis_component_index) if slices in self._precomputed_slices: return self._precomputed_slices[slices] else: output = NonAffineExpansionStorage.__new__(type(self), *self._shape) output.__init__(*self._shape) output._type = self._type output._content["truth_operators"] = self._content["truth_operators"] output._content["truth_operators_as_expansion_storage"] = self._content["truth_operators_as_expansion_storage"] output._content["basis_functions"] = list() output._content["basis_functions"].append(self._content["basis_functions"][0][key[0]]) output._content["basis_functions"].append(self._content["basis_functions"][1][key[1]]) output._content["basis_functions_shape"] = DelayedTransposeShape(output._content["basis_functions"]) self._precomputed_slices[slices] = output return output else: raise ValueError("Invalid type")
def __getitem__(self, key): """ return the subtensors of size "key" for every element in content. (e.g. submatrices [1:5,1:5] of the affine expansion of A) """ it = AffineExpansionStorageContent_Iterator( self._content, flags=["multi_index", "refs_ok"], op_flags=["readonly"]) slices = slice_to_array( self._content[it.multi_index], key, self._component_name_to_basis_component_length, self._component_name_to_basis_component_index) if slices in self._precomputed_slices: return self._precomputed_slices[slices] else: output = _AffineExpansionStorage.__new__( type(self), *self._content.shape) output.__init__(*self._content.shape) while not it.finished: # Slice content and assign output[it.multi_index] = self._do_slicing( self._content[it.multi_index], key) # Increment it.iternext() self._precomputed_slices[slices] = output return output
def _prepare_trivial_precomputed_slice(self, item): empty_slice = slice(None) slices = slice_to_array( item.vector, empty_slice, self._component_name_to_basis_component_length, self._component_name_to_basis_component_index) self._precomputed_slices[slices] = self
def __getitem__(self, key): assert isinstance(key, tuple) assert len(key) == 2 key_is_tuple_of_slices = all([isinstance(key_i, slice) for key_i in key]) key_is_tuple_of_tuples_or_lists = all([isinstance(key_i, (list, tuple)) for key_i in key]) key_is_tuple_of_int = all([isinstance(key_i, int) for key_i in key]) if ( key_is_tuple_of_slices # matrix[:5, :5] or key_is_tuple_of_tuples_or_lists # matrix[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4]] ): assert key_is_tuple_of_slices is not key_is_tuple_of_tuples_or_lists if key_is_tuple_of_slices: # matrix[:5, :5] output_content = self.content[ wrapping.Slicer(*slice_to_array(self, key, self._component_name_to_basis_component_length, self._component_name_to_basis_component_index))] output_size = slice_to_size(self, key, self._component_name_to_basis_component_length) elif key_is_tuple_of_tuples_or_lists: # matrix[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4]] output_content = self.content[wrapping.Slicer(*key)] output_size = (len(key[0]), len(key[1])) # Prepare output assert len(output_size) == 2 output = Matrix_Class.__new__(type(self), output_size[0], output_size[1], output_content) output.__init__(output_size[0], output_size[1], output_content) # Preserve auxiliary attributes related to basis functions matrix output._component_name_to_basis_component_index = self._component_name_to_basis_component_index if ( self._component_name_to_basis_component_length[0] is None and self._component_name_to_basis_component_length[1] is None ): output._component_name_to_basis_component_length = (None, None) else: if key_is_tuple_of_slices: # matrix[:5, :5] output._component_name_to_basis_component_length = tuple(output_size) elif key_is_tuple_of_tuples_or_lists: # matrix[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4]] component_name_to_basis_component_length = [None, None] for i in range(2): if len(self._component_name_to_basis_component_length[i]) == 1: for (component_name, _) in self._component_name_to_basis_component_length[i].items(): break component_name_to_basis_component_length_i = OnlineSizeDict() component_name_to_basis_component_length_i[component_name] = len(key[i]) component_name_to_basis_component_length[i] = component_name_to_basis_component_length_i else: raise NotImplementedError( "Matrix.__getitem__ with list or tuple input arguments" + " has not been implemented yet for the case of multiple components") output._component_name_to_basis_component_length = tuple( component_name_to_basis_component_length) return output elif key_is_tuple_of_int: # matrix[5, 5] output = self.content[key] assert isinstance(output, Number) return output else: raise TypeError("Unsupported key type in Matrix.__getitem__")
def __getitem__(self, key): if (isinstance(key, slice) # vector[:5] or isinstance(key, (list, tuple)) # vector[[0, 1, 2, 3, 4]] ): if isinstance(key, slice): # vector[:5] output_content = self.content[wrapping.Slicer( slice_to_array( self, key, self._component_name_to_basis_component_length, self._component_name_to_basis_component_index))] output_size = slice_to_size( self, key, self._component_name_to_basis_component_length) elif isinstance(key, (list, tuple)): # vector[[0, 1, 2, 3, 4]] output_content = self.content[wrapping.Slicer(key)] output_size = (len(key), ) # Prepare output assert len(output_size) == 1 output = Vector_Class.__new__(type(self), output_size[0], output_content) output.__init__(output_size[0], output_content) # Preserve auxiliary attributes related to basis functions matrix output._component_name_to_basis_component_index = self._component_name_to_basis_component_index if self._component_name_to_basis_component_length is None: output._component_name_to_basis_component_length = None else: if isinstance(key, slice): # vector[:5] output._component_name_to_basis_component_length = output_size[ 0] elif isinstance(key, (list, tuple)): # vector[[0, 1, 2, 3, 4]] if len(self._component_name_to_basis_component_length ) == 1: for ( component_name, _ ) in self._component_name_to_basis_component_length.items( ): break component_name_to_basis_component_length = OnlineSizeDict( ) component_name_to_basis_component_length[ component_name] = len(key) output._component_name_to_basis_component_length = component_name_to_basis_component_length else: raise NotImplementedError( "Vector.__getitem__ with list or tuple input arguments has not been implemented yet" + " for the case of multiple components") return output elif isinstance(key, int): # vector[5] output = self.content[key] assert isinstance(output, Number) return output else: raise TypeError("Unsupported key type in Vector.__getitem__")
def __setitem__(self, key, value): if ( isinstance(key, slice) # vector[:5] or isinstance(key, (list, tuple)) # vector[[0, 1, 2, 3, 4]] ): if isinstance(key, slice): # vector[:5] converted_key = wrapping.Slicer( slice_to_array(self, key, self._component_name_to_basis_component_length, self._component_name_to_basis_component_index)) elif isinstance(key, (list, tuple)): # vector[[0, 1, 2, 3, 4]] converted_key = wrapping.Slicer(key) if isinstance(value, type(self)): value = value.content self.content[converted_key] = value elif isinstance(key, int): # vector[5] self.content[key] = value else: raise TypeError("Unsupported key type in Vector.__setitem__")