etomica.space

## Interface Tensor

• ### Method Summary

All Methods
Modifier and Type Method and Description
`void` `assignTo(double[] d)`
Fills the given array with the elements of this tensor.
`void` `assignTo(double[][] d)`
`void` `assignTo(IVectorMutable[] v)`
Assigns the tensor elements column-wise to the given vectors.
`java.lang.Object` `clone()`
`double` ```component(int i, int j)```
`int` `D()`
`void` `DE(Tensor t)`
`double` `determinant()`
`void` `E(double a)`
`void` `E(double[][] d)`
Sets the tensor elements using the elements of the array.
`void` `E(IVector[] v)`
Fills the tensor column-wise with the given vectors.
`void` `E(Tensor t)`
`void` ```Ev1v2(IVector v1, IVector v2)```
Sets this equal to the dyadic or outer product of the given vectors.
`void` `invert()`
`boolean` `isNaN()`
`void` `map(IFunction f)`
`void` `ME(Tensor t)`
`void` ```MEv1v2(IVector v1, IVector v2)```
`void` `PE(double a)`
`void` ```PE(int i, int j, double a)```
`void` `PE(Tensor t)`
`void` ```PEa1Tt1(double a1, Tensor t1)```
`void` ```PEv1v2(IVector v1, IVector v2)```
Increments this by the dyadic or outer product of the given vectors.
`void` ```setComponent(int i, int j, double d)```
`void` `TE(double a)`
`void` `TE(Tensor t)`
`double[]` `toArray()`
`double` `trace()`
`void` `transform(IVectorMutable A)`
Applies the given tensor transformation to this vector, replaced its elements with the transformed values.
`void` `transpose()`
• ### Method Detail

• #### clone

`java.lang.Object clone()`
• #### D

`int D()`
• #### component

```double component(int i,
int j)```
• #### setComponent

```void setComponent(int i,
int j,
double d)```
• #### E

`void E(Tensor t)`
• #### E

`void E(IVector[] v)`
Fills the tensor column-wise with the given vectors. The number of vectors must equal the dimension of the tensor, and the vector dimensions must equal the tensor dimension.
Parameters:
`v` -
• #### assignTo

`void assignTo(IVectorMutable[] v)`
Assigns the tensor elements column-wise to the given vectors. The number of vectors must equal the dimension of the tensor, and the vector dimensions must equal the tensor dimension.
• #### Ev1v2

```void Ev1v2(IVector v1,
IVector v2)```
Sets this equal to the dyadic or outer product of the given vectors. Element ab is given by v1.a * v2.b
• #### E

`void E(double a)`
• #### PE

`void PE(double a)`
• #### PE

`void PE(Tensor t)`
• #### PE

```void PE(int i,
int j,
double a)```
• #### PEv1v2

```void PEv1v2(IVector v1,
IVector v2)```
Increments this by the dyadic or outer product of the given vectors.
• #### MEv1v2

```void MEv1v2(IVector v1,
IVector v2)```
• #### ME

`void ME(Tensor t)`
• #### PEa1Tt1

```void PEa1Tt1(double a1,
Tensor t1)```
• #### trace

`double trace()`
• #### transpose

`void transpose()`
• #### determinant

`double determinant()`
• #### invert

`void invert()`
• #### TE

`void TE(double a)`
• #### TE

`void TE(Tensor t)`
• #### DE

`void DE(Tensor t)`
• #### toArray

`double[] toArray()`
• #### isNaN

`boolean isNaN()`
• #### map

`void map(IFunction f)`
• #### E

`void E(double[][] d)`
Sets the tensor elements using the elements of the array. Tensor values are filled row-wise, so array values 0, 1, 2,... are assigned to xx, xy, xz, yx, etc. respectively.
• #### transform

`void transform(IVectorMutable A)`
Applies the given tensor transformation to this vector, replaced its elements with the transformed values.
• #### assignTo

`void assignTo(double[] d)`
Fills the given array with the elements of this tensor. Array values 0, 1, 2,... are assigned from xx, xy, xz, yx, etc. respectively, filling in a row-wise fashion.
Parameters:
`d` -
• #### assignTo

`void assignTo(double[][] d)`