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));
}
