public static Tensor Constant(float value, IAllocator allocator, DType dtype, params long[] sizes) { Tensor tensor = new Tensor(allocator, dtype, sizes); TOps.Fill(tensor, value); return(tensor); }
public static NDArray Constant(float value, IAllocator allocator, DType dtype, params long[] sizes) { NDArray tensor = new NDArray(allocator, dtype, sizes); TOps.Fill(tensor, value); return(tensor); }
public static NDArray Maximum(NDArray a, float b) { var b_t = new NDArray(a.Allocator, a.ElementType, a.Shape); TOps.Fill(b_t, b); return(Maximum(a, b_t)); }
public static NDArray Maximum(float a, NDArray b) { var a_t = new NDArray(b.Allocator, b.ElementType, b.Shape); TOps.Fill(a_t, a); return(Maximum(a_t, b)); }
public static Tensor Maximum(Tensor a, float b) { var b_t = new Tensor(a.Allocator, a.ElementType, a.Shape); TOps.Fill(b_t, b); return(Maximum(a, b_t)); }
public static Tensor Maximum(float a, Tensor b) { var a_t = new Tensor(b.Allocator, b.ElementType, b.Shape); TOps.Fill(a_t, a); return(Maximum(a_t, b)); }
/// <summary> /// Transposes the specified dimension1. /// </summary> /// <param name="dimension1">The dimension1.</param> /// <param name="dimension2">The dimension2.</param> /// <returns>Tensor.</returns> /// <exception cref="ArgumentOutOfRangeException"> /// dimension1 /// or /// dimension2 /// </exception> private NDArray Transpose(int dimension1, int dimension2, bool NewContiguous = false) { if (dimension1 < 0 || dimension1 >= DimensionCount) { throw new ArgumentOutOfRangeException("dimension1"); } if (dimension2 < 0 || dimension2 >= DimensionCount) { throw new ArgumentOutOfRangeException("dimension2"); } if (dimension1 == dimension2) { storage.AddRef(); return(this); } var newSizes = (long[])shape.Clone(); var newStrides = (long[])strides.Clone(); ArraySwap(newSizes, dimension1, dimension2); ArraySwap(newStrides, dimension1, dimension2); if (NewContiguous) { return(TOps.NewContiguous(new NDArray(newSizes, newStrides, storage, storageOffset)).Reshape(newSizes)); } return(new NDArray(newSizes, newStrides, storage, storageOffset)); }
public static Tensor operator /(Tensor lhs, Tensor rhs) { if (rhs.DimensionCount == 1) { return(TOps.Div(lhs, rhs.ToArray().Cast <float>().First())); } if (lhs.DimensionCount == 1) { return(TOps.Div(lhs.ToArray().Cast <float>().First(), rhs)); } (lhs, rhs) = TOps.Broadcast_Div(lhs, rhs); return(TOps.Div(lhs, rhs)); }
public static Tensor operator *(float lhs, Tensor rhs) { return(TOps.Mul(rhs, lhs)); }
public static Tensor operator *(Tensor lhs, float rhs) { return(TOps.Mul(lhs, rhs)); }
public static NDArray operator <(NDArray lhs, NDArray rhs) { return(TOps.GreaterThan(rhs, lhs)); }
public void Fill(float value) { TOps.Fill(this, value); }
public static Tensor operator <=(Tensor lhs, float rhs) { Tensor rhs_t = Tensor.Constant(rhs, lhs.Allocator, lhs.ElementType, lhs.shape); return(TOps.GreaterOrEqual(rhs_t, lhs)); }
public static Tensor operator >=(Tensor lhs, float rhs) { return(TOps.GreaterOrEqual(lhs, rhs)); }
public static Tensor operator >(Tensor lhs, float rhs) { return(TOps.GreaterThan(lhs, rhs)); }
public static Tensor operator /(Tensor lhs, float rhs) { return(TOps.Div(lhs, rhs)); }
public NDArray Tile(long repetitions) { return(TOps.Tile(this, repetitions)); }
public static NDArray operator <=(NDArray lhs, float rhs) { NDArray rhs_t = NDArray.Constant(rhs, lhs.Allocator, lhs.ElementType, lhs.shape); return(TOps.GreaterOrEqual(rhs_t, lhs)); }
public static NDArray operator <=(NDArray lhs, NDArray rhs) { return(TOps.GreaterOrEqual(rhs, lhs)); }
public static NDArray operator >=(NDArray lhs, float rhs) { return(TOps.GreaterOrEqual(lhs, rhs)); }
public static Tensor operator /(float lhs, Tensor rhs) { return(TOps.Div(rhs, lhs)); }
public static Tensor operator +(Tensor lhs, float rhs) { return(TOps.Add(lhs, rhs)); }
public static Tensor operator <(Tensor lhs, Tensor rhs) { return(TOps.GreaterThan(rhs, lhs)); }
public static Tensor operator +(float lhs, Tensor rhs) { return(TOps.Add(rhs, lhs)); }
public static Tensor operator <=(Tensor lhs, Tensor rhs) { return(TOps.GreaterOrEqual(rhs, lhs)); }
public static NDArray operator /(float lhs, NDArray rhs) { return(TOps.Div(rhs, lhs)); }
public Tensor Tile(long repetitions) { return(TOps.Tile(this, repetitions)); }
public static Tensor operator -(float lhs, Tensor rhs) { return(TOps.Sub(lhs, rhs)); }
public static Tensor operator -(Tensor lhs, float rhs) { return(TOps.Sub(lhs, rhs)); }
public static NDArray operator >(NDArray lhs, float rhs) { return(TOps.GreaterThan(lhs, rhs)); }