All Implemented Interfaces:

swim.codec.Debug

Direct Known Subclasses:

MutableTensor
```
public class Tensor
extends Object
implements swim.codec.Debug
```

Field Summary

Fields
Modifier and Type Field Description

Object array

TensorDims dims

int offset

Constructor Summary

Constructors
Modifier	Constructor	Description
	`Tensor(TensorDims dims, double... array)`
	`Tensor(TensorDims dims, double[] array, int offset)`
	`Tensor(TensorDims dims, float... array)`
	`Tensor(TensorDims dims, float[] array, int offset)`
`protected`	`Tensor(TensorDims dims, Object array, int offset)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`static void`	`add(TensorDims ud, double[] us, int ui, TensorDims vd, double[] vs, int vi, TensorDims wd, double[] ws, int wi)`
`static void`	`add(TensorDims ud, double[] us, int ui, TensorDims vd, double[] vs, int vi, TensorDims wd, float[] ws, int wi)`
`static void`	`add(TensorDims ud, double[] us, int ui, TensorDims vd, float[] vs, int vi, TensorDims wd, double[] ws, int wi)`
`static void`	`add(TensorDims ud, double[] us, int ui, TensorDims vd, float[] vs, int vi, TensorDims wd, float[] ws, int wi)`
`static void`	`add(TensorDims ud, float[] us, int ui, TensorDims vd, double[] vs, int vi, TensorDims wd, double[] ws, int wi)`
`static void`	`add(TensorDims ud, float[] us, int ui, TensorDims vd, double[] vs, int vi, TensorDims wd, float[] ws, int wi)`
`static void`	`add(TensorDims ud, float[] us, int ui, TensorDims vd, float[] vs, int vi, TensorDims wd, double[] ws, int wi)`
`static void`	`add(TensorDims ud, float[] us, int ui, TensorDims vd, float[] vs, int vi, TensorDims wd, float[] ws, int wi)`
`static void`	`add(TensorDims ud, Object us, int ui, TensorDims vd, Object vs, int vi, TensorDims wd, Object ws, int wi)`
`static Tensor`	`add(Tensor u, Tensor v)`
`static void`	`add(Tensor u, Tensor v, MutableTensor w)`
`static Tensor`	`add(Tensor u, Tensor v, TensorDims wd, Precision wp)`
`static void`	`cast(String tag, swim.structure.Item item, TensorDims wd, double[] ws, int wi)`
`static void`	`cast(String tag, swim.structure.Item item, TensorDims wd, float[] ws, int wi)`
`static Tensor`	`cast(String tag, swim.structure.Item item, TensorDims wd, Precision wp)`
`static void`	`combine(double a, TensorDims ud, double[] us, int ui, double b, TensorDims vd, double[] vs, int vi, TensorDims wd, double[] ws, int wi)`
`static void`	`combine(double a, TensorDims ud, double[] us, int ui, double b, TensorDims vd, double[] vs, int vi, TensorDims wd, float[] ws, int wi)`
`static void`	`combine(double a, TensorDims ud, double[] us, int ui, double b, TensorDims vd, float[] vs, int vi, TensorDims wd, double[] ws, int wi)`
`static void`	`combine(double a, TensorDims ud, double[] us, int ui, double b, TensorDims vd, float[] vs, int vi, TensorDims wd, float[] ws, int wi)`
`static void`	`combine(double a, TensorDims ud, float[] us, int ui, double b, TensorDims vd, double[] vs, int vi, TensorDims wd, double[] ws, int wi)`
`static void`	`combine(double a, TensorDims ud, float[] us, int ui, double b, TensorDims vd, double[] vs, int vi, TensorDims wd, float[] ws, int wi)`
`static void`	`combine(double a, TensorDims ud, float[] us, int ui, double b, TensorDims vd, float[] vs, int vi, TensorDims wd, double[] ws, int wi)`
`static void`	`combine(double a, TensorDims ud, float[] us, int ui, double b, TensorDims vd, float[] vs, int vi, TensorDims wd, float[] ws, int wi)`
`static void`	`combine(double a, TensorDims ud, Object us, int ui, double b, TensorDims vd, Object vs, int vi, TensorDims wd, Object ws, int wi)`
`static Tensor`	`combine(double a, Tensor u, double b, Tensor v)`
`static void`	`combine(double a, Tensor u, double b, Tensor v, MutableTensor w)`
`static Tensor`	`combine(double a, Tensor u, double b, Tensor v, TensorDims wd, Precision wp)`
`static void`	`copy(TensorDims ud, double[] us, int ui, TensorDims wd, double[] ws, int wi)`
`static void`	`copy(TensorDims ud, double[] us, int ui, TensorDims wd, float[] ws, int wi)`
`static void`	`copy(TensorDims ud, float[] us, int ui, TensorDims wd, double[] ws, int wi)`
`static void`	`copy(TensorDims ud, float[] us, int ui, TensorDims wd, float[] ws, int wi)`
`void`	`debug(swim.codec.Output<?> output)`
`TensorDims`	`dimensions()`
`boolean`	`equals(Object other)`
`static TensorForm<Tensor>`	`form(TensorDims dims)`
`static TensorForm<Tensor>`	`form(TensorDims dims, Precision prec)`
`int`	`getArrayOffset()`
`double`	`getDouble(int... coords)`
`double[]`	`getDoubleArray()`
`float`	`getFloat(int... coords)`
`float[]`	`getFloatArray()`
`protected static int`	`getOffset(TensorDims dim, int[] coords, int offset)`
`int`	`hashCode()`
`Tensor`	`minus(Tensor that)`
`static swim.structure.Item`	`mold(String tag, Tensor u)`
`static swim.structure.Item`	`mold(String tag, TensorDims ud, double[] us, int ui)`
`static swim.structure.Item`	`mold(String tag, TensorDims ud, float[] us, int ui)`
`static Tensor`	`multiply(double a, Tensor u)`
`static void`	`multiply(double a, TensorDims ud, double[] us, int ui, TensorDims wd, double[] ws, int wi)`
`static void`	`multiply(double a, TensorDims ud, double[] us, int ui, TensorDims wd, float[] ws, int wi)`
`static void`	`multiply(double a, TensorDims ud, float[] us, int ui, TensorDims wd, double[] ws, int wi)`
`static void`	`multiply(double a, TensorDims ud, float[] us, int ui, TensorDims wd, float[] ws, int wi)`
`static void`	`multiply(double a, TensorDims ud, Object us, int ui, TensorDims wd, Object ws, int wi)`
`static void`	`multiply(double a, Tensor u, MutableTensor w)`
`static Tensor`	`multiply(double a, Tensor u, TensorDims wd, Precision wp)`
`static void`	`multiply(TensorDims ud, double[] us, int ui, TensorDims vd, double[] vs, int vi, TensorDims wd, double[] ws, int wi)`
`static void`	`multiply(TensorDims ud, double[] us, int ui, TensorDims vd, double[] vs, int vi, TensorDims wd, float[] ws, int wi)`
`static void`	`multiply(TensorDims ud, double[] us, int ui, TensorDims vd, float[] vs, int vi, TensorDims wd, double[] ws, int wi)`
`static void`	`multiply(TensorDims ud, double[] us, int ui, TensorDims vd, float[] vs, int vi, TensorDims wd, float[] ws, int wi)`
`static void`	`multiply(TensorDims ud, float[] us, int ui, TensorDims vd, double[] vs, int vi, TensorDims wd, double[] ws, int wi)`
`static void`	`multiply(TensorDims ud, float[] us, int ui, TensorDims vd, double[] vs, int vi, TensorDims wd, float[] ws, int wi)`
`static void`	`multiply(TensorDims ud, float[] us, int ui, TensorDims vd, float[] vs, int vi, TensorDims wd, double[] ws, int wi)`
`static void`	`multiply(TensorDims ud, float[] us, int ui, TensorDims vd, float[] vs, int vi, TensorDims wd, float[] ws, int wi)`
`static void`	`multiply(TensorDims ud, Object us, int ui, TensorDims vd, Object vs, int vi, TensorDims wd, Object ws, int wi)`
`static Tensor`	`multiply(Tensor u, Tensor v)`
`static void`	`multiply(Tensor u, Tensor v, MutableTensor w)`
`static Tensor`	`multiply(Tensor u, Tensor v, TensorDims wd, Precision wp)`
`static void`	`multiplyMatrix(TensorDims ud, double[] us, int ui, boolean ut, TensorDims vd, double[] vs, int vi, boolean vt, TensorDims wd, double[] ws, int wi, boolean wt)`
`static void`	`multiplyMatrix(TensorDims ud, double[] us, int ui, boolean ut, TensorDims vd, double[] vs, int vi, boolean vt, TensorDims wd, float[] ws, int wi, boolean wt)`
`static void`	`multiplyMatrix(TensorDims ud, double[] us, int ui, boolean ut, TensorDims vd, float[] vs, int vi, boolean vt, TensorDims wd, double[] ws, int wi, boolean wt)`
`static void`	`multiplyMatrix(TensorDims ud, double[] us, int ui, boolean ut, TensorDims vd, float[] vs, int vi, boolean vt, TensorDims wd, float[] ws, int wi, boolean wt)`
`static void`	`multiplyMatrix(TensorDims ud, float[] us, int ui, boolean ut, TensorDims vd, double[] vs, int vi, boolean vt, TensorDims wd, double[] ws, int wi, boolean wt)`
`static void`	`multiplyMatrix(TensorDims ud, float[] us, int ui, boolean ut, TensorDims vd, double[] vs, int vi, boolean vt, TensorDims wd, float[] ws, int wi, boolean wt)`
`static void`	`multiplyMatrix(TensorDims ud, float[] us, int ui, boolean ut, TensorDims vd, float[] vs, int vi, boolean vt, TensorDims wd, double[] ws, int wi, boolean wt)`
`static void`	`multiplyMatrix(TensorDims ud, float[] us, int ui, boolean ut, TensorDims vd, float[] vs, int vi, boolean vt, TensorDims wd, float[] ws, int wi, boolean wt)`
`static void`	`multiplyMatrix(TensorDims ud, Object us, int ui, boolean ut, TensorDims vd, Object vs, int vi, boolean vt, TensorDims wd, Object ws, int wi, boolean wt)`
`static void`	`multiplyMatrix(Tensor u, boolean ut, Tensor v, boolean vt, MutableTensor w, boolean wt)`
`static Tensor`	`multiplyMatrix(Tensor u, boolean ut, Tensor v, boolean vt, TensorDims wd, Precision wp, boolean wt)`
`static Tensor`	`multiplyMatrix(Tensor u, Tensor v)`
`static Tensor`	`multiplyMatrix(Tensor u, Tensor v, TensorDims wd, Precision wp)`
`static Tensor`	`of(TensorDims dims, int offset, double... array)`
`static Tensor`	`of(TensorDims dims, int offset, float... array)`
`Tensor`	`opposite()`
`static Tensor`	`opposite(Tensor u)`
`static void`	`opposite(TensorDims ud, double[] us, int ui, TensorDims wd, double[] ws, int wi)`
`static void`	`opposite(TensorDims ud, double[] us, int ui, TensorDims wd, float[] ws, int wi)`
`static void`	`opposite(TensorDims ud, float[] us, int ui, TensorDims wd, double[] ws, int wi)`
`static void`	`opposite(TensorDims ud, float[] us, int ui, TensorDims wd, float[] ws, int wi)`
`static void`	`opposite(TensorDims ud, Object us, int ui, TensorDims wd, Object ws, int wi)`
`static void`	`opposite(Tensor u, MutableTensor w)`
`static Tensor`	`opposite(Tensor u, TensorDims wd, Precision wp)`
`Tensor`	`plus(Tensor that)`
`Precision`	`precision()`
`static TensorSpace<Tensor,Double>`	`space(int n)`
`static TensorSpace<Tensor,Double>`	`space(TensorDims dims)`
`static TensorSpace<Tensor,Double>`	`space(TensorSpace<Tensor,Double> next, int n)`
`static TensorSpace<Tensor,Double>`	`space(TensorSpace<Tensor,Double> next, TensorDims dims)`
`static void`	`subtract(TensorDims ud, double[] us, int ui, TensorDims vd, double[] vs, int vi, TensorDims wd, double[] ws, int wi)`
`static void`	`subtract(TensorDims ud, double[] us, int ui, TensorDims vd, double[] vs, int vi, TensorDims wd, float[] ws, int wi)`
`static void`	`subtract(TensorDims ud, double[] us, int ui, TensorDims vd, float[] vs, int vi, TensorDims wd, double[] ws, int wi)`
`static void`	`subtract(TensorDims ud, double[] us, int ui, TensorDims vd, float[] vs, int vi, TensorDims wd, float[] ws, int wi)`
`static void`	`subtract(TensorDims ud, float[] us, int ui, TensorDims vd, double[] vs, int vi, TensorDims wd, double[] ws, int wi)`
`static void`	`subtract(TensorDims ud, float[] us, int ui, TensorDims vd, double[] vs, int vi, TensorDims wd, float[] ws, int wi)`
`static void`	`subtract(TensorDims ud, float[] us, int ui, TensorDims vd, float[] vs, int vi, TensorDims wd, double[] ws, int wi)`
`static void`	`subtract(TensorDims ud, float[] us, int ui, TensorDims vd, float[] vs, int vi, TensorDims wd, float[] ws, int wi)`
`static void`	`subtract(TensorDims ud, Object us, int ui, TensorDims vd, Object vs, int vi, TensorDims wd, Object ws, int wi)`
`static Tensor`	`subtract(Tensor u, Tensor v)`
`static void`	`subtract(Tensor u, Tensor v, MutableTensor w)`
`static Tensor`	`subtract(Tensor u, Tensor v, TensorDims wd, Precision wp)`
`Tensor`	`times(double scalar)`
`Tensor`	`times(Tensor that)`
`Tensor`	`timesMatrix(Tensor that)`
`String`	`toString()`
`static Tensor`	`zero(TensorDims dims)`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

dims
```
public final TensorDims dims
```

array
```
public final Object array
```

offset
```
public final int offset
```

Constructor Detail

Tensor

protected Tensor(TensorDims dims,
                 Object array,
                 int offset)

Tensor

public Tensor(TensorDims dims,
              double[] array,
              int offset)

Tensor

public Tensor(TensorDims dims,
              float[] array,
              int offset)

Tensor

public Tensor(TensorDims dims,
              double... array)

Tensor

public Tensor(TensorDims dims,
              float... array)

Method Detail

dimensions
```
public final TensorDims dimensions()
```

precision
```
public final Precision precision()
```

getOffset

protected static int getOffset(TensorDims dim,
                               int[] coords,
                               int offset)

getDouble

public final double getDouble(int... coords)

getFloat

public final float getFloat(int... coords)

plus

public final Tensor plus(Tensor that)

add

public static Tensor add(Tensor u,
                         Tensor v)

add

public static void add(Tensor u,
                       Tensor v,
                       MutableTensor w)

add

public static Tensor add(Tensor u,
                         Tensor v,
                         TensorDims wd,
                         Precision wp)

add

public static void add(TensorDims ud,
                       Object us,
                       int ui,
                       TensorDims vd,
                       Object vs,
                       int vi,
                       TensorDims wd,
                       Object ws,
                       int wi)

add

public static void add(TensorDims ud,
                       double[] us,
                       int ui,
                       TensorDims vd,
                       double[] vs,
                       int vi,
                       TensorDims wd,
                       double[] ws,
                       int wi)

add

public static void add(TensorDims ud,
                       double[] us,
                       int ui,
                       TensorDims vd,
                       double[] vs,
                       int vi,
                       TensorDims wd,
                       float[] ws,
                       int wi)

add

public static void add(TensorDims ud,
                       double[] us,
                       int ui,
                       TensorDims vd,
                       float[] vs,
                       int vi,
                       TensorDims wd,
                       double[] ws,
                       int wi)

add

public static void add(TensorDims ud,
                       double[] us,
                       int ui,
                       TensorDims vd,
                       float[] vs,
                       int vi,
                       TensorDims wd,
                       float[] ws,
                       int wi)

add

public static void add(TensorDims ud,
                       float[] us,
                       int ui,
                       TensorDims vd,
                       double[] vs,
                       int vi,
                       TensorDims wd,
                       double[] ws,
                       int wi)

add

public static void add(TensorDims ud,
                       float[] us,
                       int ui,
                       TensorDims vd,
                       double[] vs,
                       int vi,
                       TensorDims wd,
                       float[] ws,
                       int wi)

add

public static void add(TensorDims ud,
                       float[] us,
                       int ui,
                       TensorDims vd,
                       float[] vs,
                       int vi,
                       TensorDims wd,
                       double[] ws,
                       int wi)

add

public static void add(TensorDims ud,
                       float[] us,
                       int ui,
                       TensorDims vd,
                       float[] vs,
                       int vi,
                       TensorDims wd,
                       float[] ws,
                       int wi)

opposite
```
public final Tensor opposite()
```

opposite

public static Tensor opposite(Tensor u)

opposite

public static void opposite(Tensor u,
                            MutableTensor w)

opposite

public static Tensor opposite(Tensor u,
                              TensorDims wd,
                              Precision wp)

opposite

public static void opposite(TensorDims ud,
                            Object us,
                            int ui,
                            TensorDims wd,
                            Object ws,
                            int wi)

opposite

public static void opposite(TensorDims ud,
                            double[] us,
                            int ui,
                            TensorDims wd,
                            double[] ws,
                            int wi)

opposite

public static void opposite(TensorDims ud,
                            double[] us,
                            int ui,
                            TensorDims wd,
                            float[] ws,
                            int wi)

opposite

public static void opposite(TensorDims ud,
                            float[] us,
                            int ui,
                            TensorDims wd,
                            double[] ws,
                            int wi)

opposite

public static void opposite(TensorDims ud,
                            float[] us,
                            int ui,
                            TensorDims wd,
                            float[] ws,
                            int wi)

minus

public final Tensor minus(Tensor that)

subtract

public static Tensor subtract(Tensor u,
                              Tensor v)

subtract

public static void subtract(Tensor u,
                            Tensor v,
                            MutableTensor w)

subtract

public static Tensor subtract(Tensor u,
                              Tensor v,
                              TensorDims wd,
                              Precision wp)

subtract

public static void subtract(TensorDims ud,
                            Object us,
                            int ui,
                            TensorDims vd,
                            Object vs,
                            int vi,
                            TensorDims wd,
                            Object ws,
                            int wi)

subtract

public static void subtract(TensorDims ud,
                            double[] us,
                            int ui,
                            TensorDims vd,
                            double[] vs,
                            int vi,
                            TensorDims wd,
                            double[] ws,
                            int wi)

subtract

public static void subtract(TensorDims ud,
                            double[] us,
                            int ui,
                            TensorDims vd,
                            double[] vs,
                            int vi,
                            TensorDims wd,
                            float[] ws,
                            int wi)

subtract

public static void subtract(TensorDims ud,
                            double[] us,
                            int ui,
                            TensorDims vd,
                            float[] vs,
                            int vi,
                            TensorDims wd,
                            double[] ws,
                            int wi)

subtract

public static void subtract(TensorDims ud,
                            double[] us,
                            int ui,
                            TensorDims vd,
                            float[] vs,
                            int vi,
                            TensorDims wd,
                            float[] ws,
                            int wi)

subtract

public static void subtract(TensorDims ud,
                            float[] us,
                            int ui,
                            TensorDims vd,
                            double[] vs,
                            int vi,
                            TensorDims wd,
                            double[] ws,
                            int wi)

subtract

public static void subtract(TensorDims ud,
                            float[] us,
                            int ui,
                            TensorDims vd,
                            double[] vs,
                            int vi,
                            TensorDims wd,
                            float[] ws,
                            int wi)

subtract

public static void subtract(TensorDims ud,
                            float[] us,
                            int ui,
                            TensorDims vd,
                            float[] vs,
                            int vi,
                            TensorDims wd,
                            double[] ws,
                            int wi)

subtract

public static void subtract(TensorDims ud,
                            float[] us,
                            int ui,
                            TensorDims vd,
                            float[] vs,
                            int vi,
                            TensorDims wd,
                            float[] ws,
                            int wi)

times

public final Tensor times(double scalar)

multiply

public static Tensor multiply(double a,
                              Tensor u)

multiply

public static void multiply(double a,
                            Tensor u,
                            MutableTensor w)

multiply

public static Tensor multiply(double a,
                              Tensor u,
                              TensorDims wd,
                              Precision wp)

multiply

public static void multiply(double a,
                            TensorDims ud,
                            Object us,
                            int ui,
                            TensorDims wd,
                            Object ws,
                            int wi)

multiply

public static void multiply(double a,
                            TensorDims ud,
                            double[] us,
                            int ui,
                            TensorDims wd,
                            double[] ws,
                            int wi)

multiply

public static void multiply(double a,
                            TensorDims ud,
                            double[] us,
                            int ui,
                            TensorDims wd,
                            float[] ws,
                            int wi)

multiply

public static void multiply(double a,
                            TensorDims ud,
                            float[] us,
                            int ui,
                            TensorDims wd,
                            double[] ws,
                            int wi)

multiply

public static void multiply(double a,
                            TensorDims ud,
                            float[] us,
                            int ui,
                            TensorDims wd,
                            float[] ws,
                            int wi)

times

public final Tensor times(Tensor that)

multiply

public static Tensor multiply(Tensor u,
                              Tensor v)

multiply

public static void multiply(Tensor u,
                            Tensor v,
                            MutableTensor w)

multiply

public static Tensor multiply(Tensor u,
                              Tensor v,
                              TensorDims wd,
                              Precision wp)

multiply

public static void multiply(TensorDims ud,
                            Object us,
                            int ui,
                            TensorDims vd,
                            Object vs,
                            int vi,
                            TensorDims wd,
                            Object ws,
                            int wi)

multiply

public static void multiply(TensorDims ud,
                            double[] us,
                            int ui,
                            TensorDims vd,
                            double[] vs,
                            int vi,
                            TensorDims wd,
                            double[] ws,
                            int wi)

multiply

public static void multiply(TensorDims ud,
                            double[] us,
                            int ui,
                            TensorDims vd,
                            double[] vs,
                            int vi,
                            TensorDims wd,
                            float[] ws,
                            int wi)

multiply

public static void multiply(TensorDims ud,
                            double[] us,
                            int ui,
                            TensorDims vd,
                            float[] vs,
                            int vi,
                            TensorDims wd,
                            double[] ws,
                            int wi)

multiply

public static void multiply(TensorDims ud,
                            double[] us,
                            int ui,
                            TensorDims vd,
                            float[] vs,
                            int vi,
                            TensorDims wd,
                            float[] ws,
                            int wi)

multiply

public static void multiply(TensorDims ud,
                            float[] us,
                            int ui,
                            TensorDims vd,
                            double[] vs,
                            int vi,
                            TensorDims wd,
                            double[] ws,
                            int wi)

multiply

public static void multiply(TensorDims ud,
                            float[] us,
                            int ui,
                            TensorDims vd,
                            double[] vs,
                            int vi,
                            TensorDims wd,
                            float[] ws,
                            int wi)

multiply

public static void multiply(TensorDims ud,
                            float[] us,
                            int ui,
                            TensorDims vd,
                            float[] vs,
                            int vi,
                            TensorDims wd,
                            double[] ws,
                            int wi)

multiply

public static void multiply(TensorDims ud,
                            float[] us,
                            int ui,
                            TensorDims vd,
                            float[] vs,
                            int vi,
                            TensorDims wd,
                            float[] ws,
                            int wi)

timesMatrix

public final Tensor timesMatrix(Tensor that)

multiplyMatrix

public static Tensor multiplyMatrix(Tensor u,
                                    Tensor v)

multiplyMatrix

public static Tensor multiplyMatrix(Tensor u,
                                    Tensor v,
                                    TensorDims wd,
                                    Precision wp)

multiplyMatrix

public static void multiplyMatrix(Tensor u,
                                  boolean ut,
                                  Tensor v,
                                  boolean vt,
                                  MutableTensor w,
                                  boolean wt)

multiplyMatrix

public static Tensor multiplyMatrix(Tensor u,
                                    boolean ut,
                                    Tensor v,
                                    boolean vt,
                                    TensorDims wd,
                                    Precision wp,
                                    boolean wt)

multiplyMatrix

public static void multiplyMatrix(TensorDims ud,
                                  Object us,
                                  int ui,
                                  boolean ut,
                                  TensorDims vd,
                                  Object vs,
                                  int vi,
                                  boolean vt,
                                  TensorDims wd,
                                  Object ws,
                                  int wi,
                                  boolean wt)

multiplyMatrix

public static void multiplyMatrix(TensorDims ud,
                                  double[] us,
                                  int ui,
                                  boolean ut,
                                  TensorDims vd,
                                  double[] vs,
                                  int vi,
                                  boolean vt,
                                  TensorDims wd,
                                  double[] ws,
                                  int wi,
                                  boolean wt)

multiplyMatrix

public static void multiplyMatrix(TensorDims ud,
                                  double[] us,
                                  int ui,
                                  boolean ut,
                                  TensorDims vd,
                                  double[] vs,
                                  int vi,
                                  boolean vt,
                                  TensorDims wd,
                                  float[] ws,
                                  int wi,
                                  boolean wt)

multiplyMatrix

public static void multiplyMatrix(TensorDims ud,
                                  double[] us,
                                  int ui,
                                  boolean ut,
                                  TensorDims vd,
                                  float[] vs,
                                  int vi,
                                  boolean vt,
                                  TensorDims wd,
                                  double[] ws,
                                  int wi,
                                  boolean wt)

multiplyMatrix

public static void multiplyMatrix(TensorDims ud,
                                  double[] us,
                                  int ui,
                                  boolean ut,
                                  TensorDims vd,
                                  float[] vs,
                                  int vi,
                                  boolean vt,
                                  TensorDims wd,
                                  float[] ws,
                                  int wi,
                                  boolean wt)

multiplyMatrix

public static void multiplyMatrix(TensorDims ud,
                                  float[] us,
                                  int ui,
                                  boolean ut,
                                  TensorDims vd,
                                  double[] vs,
                                  int vi,
                                  boolean vt,
                                  TensorDims wd,
                                  double[] ws,
                                  int wi,
                                  boolean wt)

multiplyMatrix

public static void multiplyMatrix(TensorDims ud,
                                  float[] us,
                                  int ui,
                                  boolean ut,
                                  TensorDims vd,
                                  double[] vs,
                                  int vi,
                                  boolean vt,
                                  TensorDims wd,
                                  float[] ws,
                                  int wi,
                                  boolean wt)

multiplyMatrix

public static void multiplyMatrix(TensorDims ud,
                                  float[] us,
                                  int ui,
                                  boolean ut,
                                  TensorDims vd,
                                  float[] vs,
                                  int vi,
                                  boolean vt,
                                  TensorDims wd,
                                  double[] ws,
                                  int wi,
                                  boolean wt)

multiplyMatrix

public static void multiplyMatrix(TensorDims ud,
                                  float[] us,
                                  int ui,
                                  boolean ut,
                                  TensorDims vd,
                                  float[] vs,
                                  int vi,
                                  boolean vt,
                                  TensorDims wd,
                                  float[] ws,
                                  int wi,
                                  boolean wt)

combine

public static Tensor combine(double a,
                             Tensor u,
                             double b,
                             Tensor v)

combine

public static void combine(double a,
                           Tensor u,
                           double b,
                           Tensor v,
                           MutableTensor w)

combine

public static Tensor combine(double a,
                             Tensor u,
                             double b,
                             Tensor v,
                             TensorDims wd,
                             Precision wp)

combine

public static void combine(double a,
                           TensorDims ud,
                           Object us,
                           int ui,
                           double b,
                           TensorDims vd,
                           Object vs,
                           int vi,
                           TensorDims wd,
                           Object ws,
                           int wi)

combine

public static void combine(double a,
                           TensorDims ud,
                           double[] us,
                           int ui,
                           double b,
                           TensorDims vd,
                           double[] vs,
                           int vi,
                           TensorDims wd,
                           double[] ws,
                           int wi)

combine

public static void combine(double a,
                           TensorDims ud,
                           double[] us,
                           int ui,
                           double b,
                           TensorDims vd,
                           double[] vs,
                           int vi,
                           TensorDims wd,
                           float[] ws,
                           int wi)

combine

public static void combine(double a,
                           TensorDims ud,
                           double[] us,
                           int ui,
                           double b,
                           TensorDims vd,
                           float[] vs,
                           int vi,
                           TensorDims wd,
                           double[] ws,
                           int wi)

combine

public static void combine(double a,
                           TensorDims ud,
                           double[] us,
                           int ui,
                           double b,
                           TensorDims vd,
                           float[] vs,
                           int vi,
                           TensorDims wd,
                           float[] ws,
                           int wi)

combine

public static void combine(double a,
                           TensorDims ud,
                           float[] us,
                           int ui,
                           double b,
                           TensorDims vd,
                           double[] vs,
                           int vi,
                           TensorDims wd,
                           double[] ws,
                           int wi)

combine

public static void combine(double a,
                           TensorDims ud,
                           float[] us,
                           int ui,
                           double b,
                           TensorDims vd,
                           double[] vs,
                           int vi,
                           TensorDims wd,
                           float[] ws,
                           int wi)

combine

public static void combine(double a,
                           TensorDims ud,
                           float[] us,
                           int ui,
                           double b,
                           TensorDims vd,
                           float[] vs,
                           int vi,
                           TensorDims wd,
                           double[] ws,
                           int wi)

combine

public static void combine(double a,
                           TensorDims ud,
                           float[] us,
                           int ui,
                           double b,
                           TensorDims vd,
                           float[] vs,
                           int vi,
                           TensorDims wd,
                           float[] ws,
                           int wi)

getDoubleArray

public final double[] getDoubleArray()

getFloatArray
```
public final float[] getFloatArray()
```

getArrayOffset
```
public final int getArrayOffset()
```

equals

public boolean equals(Object other)

Overrides:: equals in class Object

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class Object

debug

public void debug(swim.codec.Output<?> output)

Specified by:: debug in interface swim.codec.Debug

toString
```
public String toString()
```
Overrides:

toString in class Object

zero

public static Tensor zero(TensorDims dims)

of

public static Tensor of(TensorDims dims,
                        int offset,
                        double... array)

of

public static Tensor of(TensorDims dims,
                        int offset,
                        float... array)

space

public static TensorSpace<Tensor,Double> space(TensorSpace<Tensor,Double> next,
                                                     TensorDims dims)

space

public static TensorSpace<Tensor,Double> space(TensorSpace<Tensor,Double> next,
                                                     int n)

space

public static TensorSpace<Tensor,Double> space(TensorDims dims)

space

public static TensorSpace<Tensor,Double> space(int n)

form

public static TensorForm<Tensor> form(TensorDims dims,
                                      Precision prec)

form

public static TensorForm<Tensor> form(TensorDims dims)

mold

public static swim.structure.Item mold(String tag,
                                       Tensor u)

mold

public static swim.structure.Item mold(String tag,
                                       TensorDims ud,
                                       double[] us,
                                       int ui)

mold

public static swim.structure.Item mold(String tag,
                                       TensorDims ud,
                                       float[] us,
                                       int ui)

cast

public static Tensor cast(String tag,
                          swim.structure.Item item,
                          TensorDims wd,
                          Precision wp)

cast

public static void cast(String tag,
                        swim.structure.Item item,
                        TensorDims wd,
                        double[] ws,
                        int wi)

cast

public static void cast(String tag,
                        swim.structure.Item item,
                        TensorDims wd,
                        float[] ws,
                        int wi)

copy

public static void copy(TensorDims ud,
                        double[] us,
                        int ui,
                        TensorDims wd,
                        double[] ws,
                        int wi)

copy

public static void copy(TensorDims ud,
                        double[] us,
                        int ui,
                        TensorDims wd,
                        float[] ws,
                        int wi)

copy

public static void copy(TensorDims ud,
                        float[] us,
                        int ui,
                        TensorDims wd,
                        double[] ws,
                        int wi)

copy

public static void copy(TensorDims ud,
                        float[] us,
                        int ui,
                        TensorDims wd,
                        float[] ws,
                        int wi)

Class Tensor

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

dims

array

offset

Constructor Detail

Tensor

Tensor

Tensor

Tensor

Tensor

Method Detail

dimensions

precision

getOffset

getDouble

getFloat

plus

add

add

add

add

add

add

add

add

add

add

add

add

opposite

opposite

opposite

opposite

opposite

opposite

opposite

opposite

opposite

minus

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

subtract

times

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

times

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

multiply

timesMatrix

multiplyMatrix