Struct TensorVector 

pub struct TensorVector<T>(/* private fields */);

A resizable collection of tensors.

Implementations

impl<U> TensorVector<QuantitySparseVec<U>>

pub fn zero(len: usize) -> Self

impl<U> TensorVector<Quantity<U>>

pub fn zero(len: usize) -> Self

impl<const D: usize, I, U> TensorVector<TensorRank1<D, I, U>>

pub fn bounding_box(&self) -> TensorRank1List<D, I, 2, U>

pub fn zero(len: usize) -> Self

impl<const D: usize, I, J, U> TensorVector<TensorRank2SparseVec<D, I, J, U>>

pub fn zero(len: usize) -> Self

impl<const D: usize, I, J, U> TensorVector<TensorRank2<D, I, J, U>>

pub fn zero(len: usize) -> Self

impl<const D: usize, I, J, U> TensorVector<TensorVector<TensorRank2<D, I, J, U>>>

pub fn zero(len: usize) -> Self

impl<'a, const D: usize, I, U> TensorVector<&'a TensorRank1<D, I, U>>

pub fn bounding_box(&self) -> TensorRank1List<D, I, 2, U>

pub fn iter(&self) -> impl Iterator<Item = &&TensorRank1<D, I, U>>

pub fn is_empty(&self) -> bool

pub fn len(&self) -> usize

impl<T> TensorVector<T>

where T: Tensor,

pub const fn as_ptr(&self) -> *const T

Returns a raw pointer to the vector’s buffer, or a dangling raw pointer valid for zero sized reads if the vector didn’t allocate.

pub fn as_mut_slice(&mut self) -> &mut [T]

pub fn as_slice(&self) -> &[T]

Trait Implementations

impl<T> Add for TensorVector<T>

where T: Tensor,

type Output = TensorVector<T>

The resulting type after applying the + operator.

fn add(self, tensor_vec: Self) -> Self::Output

Performs the + operation.

impl<T> Add<&TensorVector<T>> for TensorVector<T>

where T: Tensor,

type Output = TensorVector<T>

The resulting type after applying the + operator.

fn add(self, tensor_vec: &Self) -> Self::Output

Performs the + operation.

impl<T> AddAssign for TensorVector<T>

where T: Tensor,

fn add_assign(&mut self, tensor_vec: Self)

Performs the += operation.

impl<T> AddAssign<&TensorVector<T>> for TensorVector<T>

where T: Tensor,

fn add_assign(&mut self, tensor_vec: &Self)

Performs the += operation.

impl<T> AssertEq for TensorVector<T>

where T: Display + PartialEq + Tensor,

fn eq(a: Self, b: TensorVector<T>) -> Result<(), AssertionError>

fn eq_within_tols( tols: &Assert, a: Self, b: TensorVector<T>, ) -> Result<(), AssertionError>

impl<T: Clone> Clone for TensorVector<T>

fn clone(&self) -> TensorVector<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, V> ContractWith<TensorVector<V>> for TensorVector<T>

where T: ContractWith<V> + Tensor, V: Tensor, <T as ContractWith<V>>::Output: Sum,

type Output = <T as ContractWith<V>>::Output

The quantity the contraction gives.

fn contract_with(&self, tensor_vector: &TensorVector<V>) -> Self::Output

Returns the full contraction with the other tensor.

impl<T: Debug> Debug for TensorVector<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Default for TensorVector<T>

where T: Tensor,

fn default() -> Self

Returns the “default value” for a type.

impl<E, T> Differentiable<T> for TensorVector<E>

where E: Differentiable<T> + Tensor, <E as Differentiable<T>>::Derivative: Tensor,

type Derivative = TensorVector<<E as Differentiable<T>>::Derivative>

The derivative with respect to the variable of integration.

impl<T> Display for TensorVector<T>

where T: Tensor,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Div<&f64> for TensorVector<T>

where T: Tensor,

type Output = TensorVector<T>

The resulting type after applying the / operator.

fn div(self, tensor_rank_0: &TensorRank0) -> Self::Output

Performs the / operation.

impl<T, V> Div<Quantity<V>> for TensorVector<T>

where T: Div<Quantity<V>> + Tensor, <T as Div<Quantity<V>>>::Output: Tensor,

type Output = TensorVector<<T as Div<Quantity<V>>>::Output>

The resulting type after applying the / operator.

fn div(self, quantity: Quantity<V>) -> Self::Output

Performs the / operation.

impl<T, V> Div<Quantity<V>> for &TensorVector<T>

where T: Clone + Div<Quantity<V>> + Tensor, <T as Div<Quantity<V>>>::Output: Tensor,

type Output = TensorVector<<T as Div<Quantity<V>>>::Output>

The resulting type after applying the / operator.

fn div(self, quantity: Quantity<V>) -> Self::Output

Performs the / operation.

impl<U, V> Div<TensorVector<QuantitySparseVec<V>>> for &QuantityVector<U>

where U: UnitDiv<V>,

type Output = TensorVector<Quantity<<U as UnitDiv<V>>::Output>>

The resulting type after applying the / operator.

fn div(self, _quantity_sparse_vec_2d: QuantitySparseVec2D<V>) -> Self::Output

Performs the / operation.

impl<const D: usize, I, J, U, V> Div<TensorVector<TensorRank2SparseVec<D, I, J, V>>> for &TensorRank1Vec<D, I, U>

where U: UnitDiv<V>,

type Output = TensorVector<TensorRank1<D, J, <U as UnitDiv<V>>::Output>>

The resulting type after applying the / operator.

fn div( self, _tensor_rank_2_sparse_vec_2d: TensorRank2SparseVec2D<D, I, J, V>, ) -> Self::Output

Performs the / operation.

impl<const D: usize, I, J, U> Div<TensorVector<TensorVector<TensorRank2<D, I, J, U>>>> for &TensorRank1Vec<D, I, U>

type Output = TensorVector<TensorRank1<D, J, U>>

The resulting type after applying the / operator.

fn div( self, _tensor_rank_2_vec_2d: TensorRank2Vec2D<D, I, J, U>, ) -> Self::Output

Performs the / operation.

impl<T> Div<f64> for TensorVector<T>

where T: Tensor,

type Output = TensorVector<T>

The resulting type after applying the / operator.

fn div(self, tensor_rank_0: TensorRank0) -> Self::Output

Performs the / operation.

impl<T> DivAssign<&f64> for TensorVector<T>

where T: Tensor,

fn div_assign(&mut self, tensor_rank_0: &TensorRank0)

Performs the /= operation.

impl<T> DivAssign<f64> for TensorVector<T>

where T: Tensor,

fn div_assign(&mut self, tensor_rank_0: TensorRank0)

Performs the /= operation.

impl<C, Y> ElasticViscoplasticElements<TensorVector<TensorList<TensorTuple<TensorRank2<3, Intermediate, Reference>, Y>, 1>>, 3> for Block<C>

where C: ElasticViscoplastic<Y>, Y: Differentiable + Tensor,

fn initial_state(&self) -> ViscoplasticStateVariables<1, Y>

fn nodal_forces_into( &self, nodal_coordinates: &NodalCoordinates<3>, state_variables: &ViscoplasticStateVariables<1, Y>, nodal_forces: &mut NodalForcesSolid<3>, ) -> Result<(), ElementModelError>

fn nodal_stiffnesses_into( &self, nodal_coordinates: &NodalCoordinates<3>, state_variables: &ViscoplasticStateVariables<1, Y>, nodal_stiffnesses: &mut NodalStiffnessesSolid<3>, ) -> Result<(), ElementModelError>

fn state_variables_evolution( &self, nodal_coordinates: &NodalCoordinates<3>, state_variables: &ViscoplasticStateVariables<1, Y>, ) -> Result<ViscoplasticEvolution<1, Y>, ElementModelError>

fn nodal_forces( &self, nodal_coordinates: &NodalCoordinates<D>, state_variables: &S, ) -> Result<NodalForcesSolid<D>, ElementModelError>

fn nodal_stiffnesses( &self, nodal_coordinates: &NodalCoordinates<D>, state_variables: &S, ) -> Result<NodalStiffnessesSolid<D>, ElementModelError>

impl<C, F, Y> ElasticViscoplasticElements<TensorVector<TensorList<TensorTuple<TensorRank2<3, Intermediate, Reference>, Y>, 1>>, 3> for Block<C, F>

where C: ElasticViscoplastic<Y>, F: ElasticViscoplasticVirtualElement<C, Y>, Y: Differentiable + Tensor,

fn initial_state(&self) -> ViscoplasticStateVariables<1, Y>

fn nodal_forces_into( &self, nodal_coordinates: &NodalCoordinates, state_variables: &ViscoplasticStateVariables<1, Y>, nodal_forces: &mut NodalForcesSolid, ) -> Result<(), ElementModelError>

fn nodal_stiffnesses_into( &self, nodal_coordinates: &NodalCoordinates, state_variables: &ViscoplasticStateVariables<1, Y>, nodal_stiffnesses: &mut NodalStiffnessesSolid, ) -> Result<(), ElementModelError>

fn state_variables_evolution( &self, nodal_coordinates: &NodalCoordinates, state_variables: &ViscoplasticStateVariables<1, Y>, ) -> Result<ViscoplasticEvolution<1, Y>, ElementModelError>

fn nodal_forces( &self, nodal_coordinates: &NodalCoordinates<D>, state_variables: &S, ) -> Result<NodalForcesSolid<D>, ElementModelError>

fn nodal_stiffnesses( &self, nodal_coordinates: &NodalCoordinates<D>, state_variables: &S, ) -> Result<NodalStiffnessesSolid<D>, ElementModelError>

impl<C, F, const G: usize, const M: usize, const N: usize, const P: usize, Y> ElasticViscoplasticElements<TensorVector<TensorList<TensorTuple<TensorRank2<3, Intermediate, Reference>, Y>, G>>, 3> for Block<C, F, G, M, N, P>

where C: ElasticViscoplastic<Y>, F: ElasticViscoplasticFiniteElement<C, G, M, N, P, Y>, Y: Differentiable + Tensor,

fn initial_state(&self) -> ViscoplasticStateVariables<G, Y>

fn nodal_forces_into( &self, nodal_coordinates: &NodalCoordinates<3>, state_variables: &ViscoplasticStateVariables<G, Y>, nodal_forces: &mut NodalForcesSolid<3>, ) -> Result<(), ElementModelError>

fn nodal_stiffnesses_into( &self, nodal_coordinates: &NodalCoordinates<3>, state_variables: &ViscoplasticStateVariables<G, Y>, nodal_stiffnesses: &mut NodalStiffnessesSolid<3>, ) -> Result<(), ElementModelError>

fn state_variables_evolution( &self, nodal_coordinates: &NodalCoordinates<3>, state_variables: &ViscoplasticStateVariables<G, Y>, ) -> Result<ViscoplasticEvolution<G, Y>, ElementModelError>

fn nodal_forces( &self, nodal_coordinates: &NodalCoordinates<D>, state_variables: &S, ) -> Result<NodalForcesSolid<D>, ElementModelError>

fn nodal_stiffnesses( &self, nodal_coordinates: &NodalCoordinates<D>, state_variables: &S, ) -> Result<NodalStiffnessesSolid<D>, ElementModelError>

impl<T> Erase for TensorVector<T>

where T: Erase + Tensor,

type Erased = TensorVector<<T as Erase>::Erased>

The tensor with its configurations and unit discarded.

fn erase(&self) -> &Self::Erased

Views the tensor with its configurations and unit discarded.

impl<T> Extend<T> for TensorVector<T>

where T: Tensor,

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = T>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<B, const D: usize> FirstOrderMinimize<Quantity<Energy>, TensorVector<TensorRank1<D, Current, Force>>, TensorVector<TensorRank1<D, Current, Length>>> for Model<B, D>

where B: HyperelasticElements<D>,

fn minimize( &self, equality_constraint: EqualityConstraint, solver: impl FirstOrderOptimization<Quantity<Energy>, NodalForcesSolid<D>, NodalCoordinates<D>>, ) -> Result<NodalCoordinates<D>, OptimizationError>

impl<B, const D: usize> FirstOrderMinimize<Quantity<PowerTemperature>, TensorVector<Quantity<Power>>, TensorVector<Quantity<Temperature>>> for Model<B, D>

where B: ThermalConductionElements,

fn minimize( &self, equality_constraint: EqualityConstraint, solver: impl FirstOrderOptimization<Quantity<PowerTemperature>, NodalForcesThermal, NodalTemperatures>, ) -> Result<NodalTemperatures, OptimizationError>

impl<B, const D: usize> FirstOrderRoot<TensorVector<Quantity<Power>>, TensorVector<QuantitySparseVec<PowerPerTemperature>>, TensorVector<Quantity<Temperature>>> for Model<B, D>

where B: ThermalConductionElements,

fn root( &self, equality_constraint: EqualityConstraint, solver: impl FirstOrderRootFinding<NodalForcesThermal, NodalStiffnessesThermal, NodalTemperatures>, ) -> Result<NodalTemperatures, OptimizationError>

impl<B, const D: usize> FirstOrderRoot<TensorVector<TensorRank1<D, Current, Force>>, TensorVector<TensorRank2SparseVec<D, Current, Current, ForcePerLength>>, TensorVector<TensorRank1<D, Current, Length>>> for Model<B, D>

where B: ElasticElements<D>,

fn root( &self, equality_constraint: EqualityConstraint, solver: impl FirstOrderRootFinding<NodalForcesSolid<D>, NodalStiffnessesSolid<D>, NodalCoordinates<D>>, ) -> Result<NodalCoordinates<D>, OptimizationError>

impl<const D: usize, U> From<&TensorVector<TensorRank1<D, Current, U>>> for TensorRank1Vec<D, Reference, U>

fn from(tensor_rank_1_vec: &TensorRank1Vec<D, Current, U>) -> Self

Converts to this type from the input type.

impl<const D: usize, I, U> From<&TensorVector<TensorRank1<D, I, U>>> for [Vec<TensorRank0>; D]

fn from(tensor_rank_1_vec: &TensorRank1Vec<D, I, U>) -> Self

Converts to this type from the input type.

impl<const D: usize, U> From<&TensorVector<TensorRank1<D, Reference, U>>> for TensorRank1Vec<D, Current, U>

fn from(tensor_rank_1_vec: &TensorRank1Vec<D, Reference, U>) -> Self

Converts to this type from the input type.

impl<T> From<&[T]> for TensorVector<T>

where T: Tensor,

fn from(slice: &[T]) -> Self

Converts to this type from the input type.

impl<'a, const D: usize> From<TensorVector<&'a TensorRank1<D, Reference, Length>>> for BoundingBox<D>

fn from(coordinates: CoordinatesRef<'a, D>) -> Self

Converts to this type from the input type.

impl<T> From<TensorVector<T>> for Vec<T>

where T: Tensor,

fn from(tensor_vector: TensorVector<T>) -> Self

Converts to this type from the input type.

impl<T> From<TensorVector<T>> for VecDeque<T>

where T: Tensor,

fn from(tensor_vector: TensorVector<T>) -> Self

Converts to this type from the input type.

impl<const D: usize, U> From<TensorVector<TensorRank1<D, Current, U>>> for TensorRank1Vec<D, Reference, U>

fn from(tensor_rank_1_vec: TensorRank1Vec<D, Current, U>) -> Self

Converts to this type from the input type.

impl<const D: usize, I, U> From<TensorVector<TensorRank1<D, I, U>>> for Vec<[TensorRank0; D]>

fn from(tensor_rank_1_vec: TensorRank1Vec<D, I, U>) -> Self

Converts to this type from the input type.

impl<const D: usize, I, U> From<TensorVector<TensorRank1<D, I, U>>> for Vec<Vec<TensorRank0>>

fn from(tensor_rank_1_vec: TensorRank1Vec<D, I, U>) -> Self

Converts to this type from the input type.

impl<const D: usize, I, U> From<TensorVector<TensorRank1<D, I, U>>> for [Vec<TensorRank0>; D]

fn from(tensor_rank_1_vec: TensorRank1Vec<D, I, U>) -> Self

Converts to this type from the input type.

impl<const D: usize, I> From<TensorVector<TensorRank1<D, I>>> for Vector

fn from(tensor_rank_1_vec: TensorRank1Vec<D, I>) -> Self

Converts to this type from the input type.

impl<const D: usize> From<TensorVector<TensorRank1<D, Reference, Length>>> for BoundingBox<D>

fn from(coordinates: Coordinates<D>) -> Self

Converts to this type from the input type.

impl<const D: usize, U> From<TensorVector<TensorRank1<D, Reference, U>>> for TensorRank1Vec<D, Current, U>

fn from(tensor_rank_1_vec: TensorRank1Vec<D, Reference, U>) -> Self

Converts to this type from the input type.

impl<const D: usize, I, J, U> From<TensorVector<TensorVector<TensorRank2<D, I, J, U>>>> for Vec<TensorRank0>

fn from(tensor_rank_2_vec_2d: TensorRank2Vec2D<D, I, J, U>) -> Self

Converts to this type from the input type.

impl<const D: usize, I, J> From<TensorVector<TensorVector<TensorRank2<D, I, J>>>> for SquareMatrix

fn from(tensor_rank_2_vec_2d: TensorRank2Vec2D<D, I, J>) -> Self

Converts to this type from the input type.

impl<T> From<Vec<T>> for TensorVector<T>

where T: Tensor,

fn from(vec: Vec<T>) -> Self

Converts to this type from the input type.

impl<T> From<VecDeque<T>> for TensorVector<T>

where T: Tensor,

fn from(vec_deque: VecDeque<T>) -> Self

Converts to this type from the input type.

impl<T, const N: usize> From<[T; N]> for TensorVector<T>

where T: Tensor,

fn from(array: [T; N]) -> Self

Converts to this type from the input type.

impl<T> FromIterator<T> for TensorVector<T>

fn from_iter<Ii: IntoIterator<Item = T>>(into_iterator: Ii) -> Self

Creates a value from an iterator.

impl<C, Y> HyperelasticViscoplasticElements<TensorVector<TensorList<TensorTuple<TensorRank2<3, Intermediate, Reference>, Y>, 1>>, 3> for Block<C>

where C: HyperelasticViscoplastic<Y>, Y: Differentiable + Tensor,

fn helmholtz_free_energy( &self, nodal_coordinates: &NodalCoordinates<3>, state_variables: &ViscoplasticStateVariables<1, Y>, ) -> Result<Quantity<Energy>, ElementModelError>

impl<C, F, Y> HyperelasticViscoplasticElements<TensorVector<TensorList<TensorTuple<TensorRank2<3, Intermediate, Reference>, Y>, 1>>, 3> for Block<C, F>

where C: HyperelasticViscoplastic<Y>, F: HyperelasticViscoplasticVirtualElement<C, Y>, Self: ElasticViscoplasticElements<ViscoplasticStateVariables<1, Y>, 3>, Y: Differentiable + Tensor,

fn helmholtz_free_energy( &self, nodal_coordinates: &NodalCoordinates, state_variables: &ViscoplasticStateVariables<1, Y>, ) -> Result<Quantity<Energy>, ElementModelError>

impl<C, F, const G: usize, const M: usize, const N: usize, const P: usize, Y> HyperelasticViscoplasticElements<TensorVector<TensorList<TensorTuple<TensorRank2<3, Intermediate, Reference>, Y>, G>>, 3> for Block<C, F, G, M, N, P>

where C: HyperelasticViscoplastic<Y>, F: HyperelasticViscoplasticFiniteElement<C, G, M, N, P, Y>, Self: ElasticViscoplasticElements<ViscoplasticStateVariables<G, Y>, 3>, Y: Differentiable + Tensor,

fn helmholtz_free_energy( &self, nodal_coordinates: &NodalCoordinates<3>, state_variables: &ViscoplasticStateVariables<G, Y>, ) -> Result<Quantity<Energy>, ElementModelError>

impl<T> Index<usize> for TensorVector<T>

where T: Tensor,

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for TensorVector<T>

where T: Tensor,

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T> IntoIterator for TensorVector<T>

where T: Tensor,

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<<TensorVector<T> as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a TensorVector<T>

where T: Tensor,

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<U> Mul<&TensorVector<Quantity<U>>> for &Vector

type Output = f64

The resulting type after applying the * operator.

fn mul(self, quantity_vector: &QuantityVector<U>) -> Self::Output

Performs the * operation.

impl<U> Mul<&TensorVector<Quantity<U>>> for &Matrix

type Output = Vector

The resulting type after applying the * operator.

fn mul(self, quantity_vector: &QuantityVector<U>) -> Self::Output

Performs the * operation.

impl<const D: usize, I, U> Mul<&TensorVector<TensorRank1<D, I, U>>> for &Vector

type Output = f64

The resulting type after applying the * operator.

fn mul(self, tensor_rank_1_vec: &TensorRank1Vec<D, I, U>) -> Self::Output

Performs the * operation.

impl<const D: usize, I, U> Mul<&TensorVector<TensorRank1<D, I, U>>> for &Matrix

type Output = Vector

The resulting type after applying the * operator.

fn mul(self, tensor_rank_1_vec: &TensorRank1Vec<D, I, U>) -> Self::Output

Performs the * operation.

impl<const D: usize, I> Mul<&TensorVector<TensorRank1<D, I>>> for &CscMatrix

type Output = Vector

The resulting type after applying the * operator.

fn mul(self, tensor_rank_1_vec: &TensorRank1Vec<D, I>) -> Self::Output

Performs the * operation.

impl<const D: usize, I, J, U, V> Mul<&TensorVector<TensorRank1<D, J, V>>> for TensorRank2<D, I, J, U>

where U: UnitMul<V>,

type Output = TensorVector<TensorRank1<D, I, <U as UnitMul<V>>::Output>>

The resulting type after applying the * operator.

fn mul(self, tensor_rank_1_vec: &TensorRank1Vec<D, J, V>) -> Self::Output

Performs the * operation.

impl<const D: usize, I, J, U, V> Mul<&TensorVector<TensorRank1<D, J, V>>> for &TensorRank2<D, I, J, U>

where U: UnitMul<V>,

type Output = TensorVector<TensorRank1<D, I, <U as UnitMul<V>>::Output>>

The resulting type after applying the * operator.

fn mul(self, tensor_rank_1_vec: &TensorRank1Vec<D, J, V>) -> Self::Output

Performs the * operation.

impl<T> Mul<&f64> for TensorVector<T>

where T: Tensor,

type Output = TensorVector<T>

The resulting type after applying the * operator.

fn mul(self, tensor_rank_0: &TensorRank0) -> Self::Output

Performs the * operation.

impl<T, V> Mul<Quantity<V>> for TensorVector<T>

where T: Mul<Quantity<V>> + Tensor, <T as Mul<Quantity<V>>>::Output: Tensor,

type Output = TensorVector<<T as Mul<Quantity<V>>>::Output>

The resulting type after applying the * operator.

fn mul(self, quantity: Quantity<V>) -> Self::Output

Performs the * operation.

impl<T, V> Mul<Quantity<V>> for &TensorVector<T>

where T: Mul<Quantity<V>> + Tensor, <T as Mul<Quantity<V>>>::Output: Tensor,

type Output = TensorVector<<T as Mul<Quantity<V>>>::Output>

The resulting type after applying the * operator.

fn mul(self, quantity: Quantity<V>) -> Self::Output

Performs the * operation.

impl<const D: usize, I, J, U, V> Mul<TensorVector<TensorRank1<D, J, V>>> for TensorRank2<D, I, J, U>

where U: UnitMul<V>,

type Output = TensorVector<TensorRank1<D, I, <U as UnitMul<V>>::Output>>

The resulting type after applying the * operator.

fn mul(self, tensor_rank_1_vec: TensorRank1Vec<D, J, V>) -> Self::Output

Performs the * operation.

impl<const D: usize, I, J, U, V> Mul<TensorVector<TensorRank1<D, J, V>>> for &TensorRank2<D, I, J, U>

where U: UnitMul<V>,

type Output = TensorVector<TensorRank1<D, I, <U as UnitMul<V>>::Output>>

The resulting type after applying the * operator.

fn mul(self, tensor_rank_1_vec: TensorRank1Vec<D, J, V>) -> Self::Output

Performs the * operation.

impl<const D: usize, I, J, K, U, V> Mul<TensorVector<TensorRank2SparseVec<D, J, K, V>>> for TensorRank2<D, I, J, U>

where U: UnitMul<V>,

type Output = TensorVector<TensorRank2SparseVec<D, I, K, <U as UnitMul<V>>::Output>>

The resulting type after applying the * operator.

fn mul( self, tensor_rank_2_sparse_vec_2d: TensorRank2SparseVec2D<D, J, K, V>, ) -> Self::Output

Performs the * operation.

impl<const D: usize, I, J, K, U, V> Mul<TensorVector<TensorVector<TensorRank2<D, J, K, V>>>> for TensorRank2<D, I, J, U>

where U: UnitMul<V>,

type Output = TensorVector<TensorVector<TensorRank2<D, I, K, <U as UnitMul<V>>::Output>>>

The resulting type after applying the * operator.

fn mul( self, tensor_rank_2_list_2d: TensorRank2Vec2D<D, J, K, V>, ) -> Self::Output

Performs the * operation.

impl<const D: usize, I, J, K, U, V> Mul<TensorVector<TensorVector<TensorRank2<D, J, K, V>>>> for &TensorRank2<D, I, J, U>

where U: UnitMul<V>,

type Output = TensorVector<TensorVector<TensorRank2<D, I, K, <U as UnitMul<V>>::Output>>>

The resulting type after applying the * operator.

fn mul( self, tensor_rank_2_list_2d: TensorRank2Vec2D<D, J, K, V>, ) -> Self::Output

Performs the * operation.

impl<T> Mul<f64> for TensorVector<T>

where T: Tensor,

type Output = TensorVector<T>

The resulting type after applying the * operator.

fn mul(self, tensor_rank_0: TensorRank0) -> Self::Output

Performs the * operation.

impl<T> Mul<f64> for &TensorVector<T>

where T: Tensor, for<'a> &'a T: Mul<&'a TensorRank0, Output = T>,

type Output = TensorVector<T>

The resulting type after applying the * operator.

fn mul(self, tensor_rank_0: TensorRank0) -> Self::Output

Performs the * operation.

impl<T> MulAssign<&f64> for TensorVector<T>

where T: Tensor,

fn mul_assign(&mut self, tensor_rank_0: &TensorRank0)

Performs the *= operation.

impl<T> MulAssign<f64> for TensorVector<T>

where T: Tensor,

fn mul_assign(&mut self, tensor_rank_0: TensorRank0)

Performs the *= operation.

impl<T: PartialEq> PartialEq for TensorVector<T>

fn eq(&self, other: &TensorVector<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<B, const D: usize> SecondOrderMinimize<Quantity<Energy>, TensorVector<TensorRank1<D, Current, Force>>, TensorRank2SparseVec2DSymmetric<D, Current, Current, ForcePerLength>, TensorVector<TensorRank1<D, Current, Length>>> for Model<B, D>

where B: HyperelasticElements<D>,

fn minimize( &self, equality_constraint: EqualityConstraint, solver: impl SecondOrderOptimization<Quantity<Energy>, NodalForcesSolid<D>, NodalStiffnessesSolidSymmetric<D>, NodalCoordinates<D>>, ) -> Result<NodalCoordinates<D>, OptimizationError>

impl<B, const D: usize> SecondOrderMinimize<Quantity<PowerTemperature>, TensorVector<Quantity<Power>>, TensorVector<QuantitySparseVec<PowerPerTemperature>>, TensorVector<Quantity<Temperature>>> for Model<B, D>

where B: ThermalConductionElements,

fn minimize( &self, equality_constraint: EqualityConstraint, solver: impl SecondOrderOptimization<Quantity<PowerTemperature>, NodalForcesThermal, NodalStiffnessesThermal, NodalTemperatures>, ) -> Result<NodalTemperatures, OptimizationError>

impl<T: PartialEq> StructuralPartialEq for TensorVector<T>

impl<T> Sub for TensorVector<T>

where T: Tensor,

type Output = TensorVector<T>

The resulting type after applying the - operator.

fn sub(self, tensor_vec: Self) -> Self::Output

Performs the - operation.

impl<T> Sub for &TensorVector<T>

where T: Tensor,

type Output = TensorVector<T>

The resulting type after applying the - operator.

fn sub(self, tensor_vec: Self) -> Self::Output

Performs the - operation.

impl<T> Sub<&TensorVector<T>> for TensorVector<T>

where T: Tensor,

type Output = TensorVector<T>

The resulting type after applying the - operator.

fn sub(self, tensor_vec: &Self) -> Self::Output

Performs the - operation.

impl<T> SubAssign for TensorVector<T>

where T: Tensor,

fn sub_assign(&mut self, tensor_vec: Self)

Performs the -= operation.

impl<T> SubAssign<&TensorVector<T>> for TensorVector<T>

where T: Tensor,

fn sub_assign(&mut self, tensor_vec: &Self)

Performs the -= operation.

impl<T> Sum for TensorVector<T>

where T: Tensor,

fn sum<Ii>(iter: Ii) -> Self

where Ii: Iterator<Item = Self>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T> Tensor for TensorVector<T>

where T: Tensor,

type Item = T

The type of item encountered when iterating over the tensor.

type Unit = <T as Tensor>::Unit

The physical unit the tensor carries.

fn iter(&self) -> impl Iterator<Item = &Self::Item>

Returns an iterator.

fn iter_mut(&mut self) -> impl Iterator<Item = &mut Self::Item>

Returns an iterator that allows modifying each value.

fn len(&self) -> usize

Returns the number of elements, also referred to as the ‘length’.

fn size(&self) -> usize

Returns the total number of entries.

fn error_count_zero(&self, tol_abs: Scalar, tol_rel: Scalar) -> Option<usize>

Returns number of nonzero entries given absolute and relative tolerances.

fn error_count( &self, other: &Self, tol_abs: Scalar, tol_rel: Scalar, ) -> Option<usize>

Returns number of different entries given absolute and relative tolerances.

fn full_contraction(&self, tensor: &Self) -> TensorRank0

Returns the full contraction with another tensor.

fn is_zero(&self) -> bool

Checks whether the tensor is the zero tensor.

fn norm(&self) -> Quantity<Self::Unit>

Returns the tensor norm.

fn norm_inf(&self) -> Quantity<Self::Unit>

Returns the infinity norm.

fn norm_l1(&self) -> Quantity<Self::Unit>

Returns the L1 (Manhattan) norm.

fn norm_p_sum(&self, p: TensorRank0) -> TensorRank0

Returns the sum of p-th powers of absolute values (used internally by norm_p).

fn norm_p(&self, p: TensorRank0) -> Quantity<Self::Unit>

Returns the Minkowski (Lp) norm.

fn norm_squared(&self) -> Quantity<Square<Self::Unit>>

where Self::Unit: UnitMul<Self::Unit>,

Returns the tensor norm squared, which carries the square of its unit.

fn normalize(&mut self)

Normalizes the tensor in place.

fn sub_abs(&self, other: &Self) -> Self

Returns the positive difference of the two tensors.

fn sub_rel(&self, other: &Self) -> Self

Returns the relative difference of the two tensors.

impl<T> TensorVec for TensorVector<T>

where T: Tensor,

type Item = T

The type of element encountered when iterating over the tensor.

fn append(&mut self, other: &mut Self)

Moves all the elements of other into self, leaving other empty.

fn capacity(&self) -> usize

Returns the total number of elements the vector can hold without reallocating.

fn is_empty(&self) -> bool

Returns true if the vector contains no elements.

fn new() -> Self

Constructs a new, empty Vec, not allocating until elements are pushed onto it.

fn push(&mut self, item: Self::Item)

Appends an element to the back of the Vec.

fn remove(&mut self, index: usize) -> Self::Item

Removes an element from the Vec and returns it, shifting elements to the left.

fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more elements to be inserted in the given Vec.

fn retain<F>(&mut self, f: F)

where F: FnMut(&Self::Item) -> bool,

Retains only the elements specified by the predicate.

fn swap_remove(&mut self, index: usize) -> Self::Item

Removes an element from the Vec and returns it, replacing it with the last element.

fn with_capacity(capacity: usize) -> Self

Constructs a new, empty vector with at least the specified capacity.

impl<B, const D: usize> ZerothOrderRoot<TensorVector<Quantity<Power>>, TensorVector<Quantity<Temperature>>> for Model<B, D>

where B: ThermalConductionElements,

fn root( &self, equality_constraint: EqualityConstraint, solver: impl ZerothOrderRootFinding<NodalForcesThermal, NodalTemperatures>, ) -> Result<NodalTemperatures, OptimizationError>

impl<B, const D: usize> ZerothOrderRoot<TensorVector<TensorRank1<D, Current, Force>>, TensorVector<TensorRank1<D, Current, Length>>> for Model<B, D>

where B: ElasticElements<D>,

fn root( &self, equality_constraint: EqualityConstraint, solver: impl ZerothOrderRootFinding<NodalForcesSolid<D>, NodalCoordinates<D>>, ) -> Result<NodalCoordinates<D>, OptimizationError>