Package etomica.space

Interface Tensor

All Superinterfaces:

java.lang.Cloneable

All Known Subinterfaces:

RotationTensor

All Known Implementing Classes:

RotationTensor1D, RotationTensor2D, RotationTensor3D, Tensor1D, Tensor2D, Tensor3D, TensorND

public interface Tensor
extends java.lang.Cloneable

Interface for a second-order tensor. Implementations differ depending on the dimension of the space where the tensor is used.

Method Summary

Modifier and Type	Method	Description
void	assignTo(double[] d)	Fills the given array with the elements of this tensor.
void	assignTo(double[][] d)	Fills the given 2-dimensional array with the elements of this tensor.
void	assignTo(Vector[] 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)	"Divide equals" (/=) operation, element-by-element.
double	determinant()	Computes the determinant of the matrix represented by this tensor
void	diagE(Vector v)	Makes this a diagonal tensor with elements set by the given vector.
void	E(double a)	"Equals" operation, setting all elements of this tensor to the given value
void	E(double[][] d)	Sets the tensor elements using the elements of the array.
void	E(Tensor t)	"Equals" operation.
void	E(Vector[] v)	Fills the tensor column-wise with the given vectors.
boolean	equals(Tensor t)	Element-by-element comparison of tensors
void	Ev1v2(Vector v1, Vector v2)	Sets this tensor equal to the dyadic or outer product of the given vectors.
void	invert()	Replaces this tensor with its inverse.
boolean	isNaN()
void	map(IFunction f)	Applies given function to each element of this tensor.
void	ME(Tensor t)	"Minus equals" (-=) operation, subtracting the elements of the given tensor from the respective elements of this tensor.
void	MEv1v2(Vector v1, Vector v2)	"Minus equals" (-=) operation with a dyad argument.
void	PE(double a)	"Plus equals" (+=) operation, adding the given value to each element of this tensor
void	PE(int i, int j, double a)	"Plus equals" (+=) operation, performed on a single element of this tensor.
void	PE(Tensor t)	"Plus equals" (+=) operation, adding the elements of the given tensor to the respective elements of this tensor
void	PEa1Tt1(double a1, Tensor t1)	"Plus equals" (+=) operation based on a scalar and tensor.
void	PEv1v2(Vector v1, Vector v2)	"Plus equals" (+=) operation with a dyad argument.
void	setComponent(int i, int j, double d)
void	TE(double a)	"Times equals" (*=) operation, replaces each element of this tensor by its current value times the given scalar
void	TE(Tensor t)	"Times equals" (*=) operation, as matrix multiplication.
double[]	toArray()	Returns tensor in a new array, writing elements row-wise.
double	trace()
void	transform(Vector x)	Applies the given tensor transformation to this vector, replacing its elements with the transformed values.
void	transpose()	Performs a transpose operation on this tensor, replacing each element ab by its counterpart element ba

Method Detail

clone

java.lang.Object clone()

Returns:

a new tensor that is a copy of this one

D

int D()

Returns:

the dimension of the space in which this tensor is defined

component

double component(int i,
                 int j)

Parameters:

i - "row" index of the requested component

j - "column" index of the requested component

Returns:

the component a_i,j of this tensor

setComponent

void setComponent(int i,
                  int j,
                  double d)

Parameters:

i - "row" index of the component being set

j - "column" index of the component being set

d - value to which the component a_i,j of this tensor is set

E

void E(Tensor t)

"Equals" operation. Sets all components of this tensor equal to those of the given tensor.

Parameters:

t - the given tensor used to set this tensor's values

E

void E(Vector[] 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. Each vector forms a column of the tensor, so for D = 3, xx = v[0].x, xy = v[1].x, xz = v[2].x,...,yx = v[0].y, etc.

Parameters:

v - the given vectors used to set this tensor's values

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][0], [0][1], [0][2],...[1][0]... are assigned to xx, xy, xz, yx, etc. respectively.

E

void E(double a)

"Equals" operation, setting all elements of this tensor to the given value

Parameters:

a - the given value used to set this tensor's elements

diagE

void diagE(Vector v)

Makes this a diagonal tensor with elements set by the given vector. All other elements of this tensor are set to zero.

Parameters:

v - the given vector

assignTo

void assignTo(Vector[] 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(Vector v1,
           Vector v2)

Sets this tensor equal to the dyadic or outer product of the given vectors. Element ab is given by v1.a * v2.b

Parameters:

v1 - first vector of the dyad

v2 - second vector of the dyad

PE

void PE(double a)

"Plus equals" (+=) operation, adding the given value to each element of this tensor

Parameters:

a - the value added to each element

PE

void PE(Tensor t)

"Plus equals" (+=) operation, adding the elements of the given tensor to the respective elements of this tensor

Parameters:

t - the given tensor added to this tensor

PE

void PE(int i,
        int j,
        double a)

"Plus equals" (+=) operation, performed on a single element of this tensor.

Parameters:

i - "row" index of the modified element

j - "column" index of the modified element

a - value to be added to the element a_i,j

PEv1v2

void PEv1v2(Vector v1,
            Vector v2)

"Plus equals" (+=) operation with a dyad argument. Increments this tensor by the dyadic or outer product of the given vectors. Element ab of this tensor is replaced by (ab + v1.a * v2.b)

MEv1v2

void MEv1v2(Vector v1,
            Vector v2)

"Minus equals" (-=) operation with a dyad argument. Decrements this tensor by the dyadic or outer product of the given vectors. Element ab of this tensor is replaced by (ab - v1.a * v2.b)

ME

void ME(Tensor t)

"Minus equals" (-=) operation, subtracting the elements of the given tensor from the respective elements of this tensor. This tensor's values are replaced by the so-computed difference.

Parameters:

t - the given tensor subtracted from this tensor

PEa1Tt1

void PEa1Tt1(double a1,
             Tensor t1)

"Plus equals" (+=) operation based on a scalar and tensor. Each element ab of this tensor is replaced by a1 * t1.ab.

Parameters:

a1 - the scalar multiplier

t1 - the given tensor

trace

double trace()

Returns:

the sum of the diagonal elements of this tensor

transpose

void transpose()

Performs a transpose operation on this tensor, replacing each element ab by its counterpart element ba

determinant

double determinant()

Computes the determinant of the matrix represented by this tensor

Returns:

the determinant of this tensor

invert

void invert()

Replaces this tensor with its inverse. The inverse is defined such that the tensor multiplied by its inverse gives the identity tensor.

TE

void TE(double a)

"Times equals" (*=) operation, replaces each element of this tensor by its current value times the given scalar

Parameters:

a - the given scalar multiplier

TE

void TE(Tensor t)

"Times equals" (*=) operation, as matrix multiplication. Replaces each element of this tensor by the value given by result of (this)*t, where multiplication is treated as if multiplying matrices.

Parameters:

t - the tensor this is multiplying

DE

void DE(Tensor t)

"Divide equals" (/=) operation, element-by-element. Replaces each element of this tensor by its current value divided by the corresponding element in the given tensor. Element ab is replated by ab / t.ab.

Parameters:

t - the given tensor

toArray

double[] toArray()

Returns tensor in a new array, writing elements row-wise. For example, in 2D: xx, xy, yx, yy.

Returns:

a new array containing the tensor elements

isNaN

boolean isNaN()

Returns:

true if any element of this tensor is NaN (not a number)

map

void map(IFunction f)

Applies given function to each element of this tensor. Replaces element with the resulting value.

Parameters:

f - the function applied to each element

transform

void transform(Vector x)

Applies the given tensor transformation to this vector, replacing its elements with the transformed values. This operation is equivalent to a matrix multiplication.

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 - an array of length D², containing the tensor elements upon return

assignTo

void assignTo(double[][] d)

Fills the given 2-dimensional array with the elements of this tensor. Array values [0][0], [0][1] are assigned from xx, xy, xz, yx, etc. respectively, such that d[i] contains the i^th row of the tensor.

Parameters:

d - a D-by-D array, containing the tensor elements upon return

equals

boolean equals(Tensor t)

Element-by-element comparison of tensors

Parameters:

t - the given tensor

Returns:

true if every element of given tensor equals the corresponding element of this tensor