Class ShortTensor
Tensor of type Short.
Inheritance
Namespace: TorchSharp
Assembly: TorchSharp.dll
Syntax
public class ShortTensor : IDisposable
Remarks
Use the default constructor to create an empty tensor, or invoke one of the constructors with one (1D), two (2D), three (3D), or four parameters (4D) to x create a tensor for the desired number of dimensions.
Constructors
ShortTensor()
Creates an empty tensor.
Declaration
public ShortTensor ();
ShortTensor(Int64)
Creates a 1D tensor of the specified size.
Declaration
public ShortTensor (long size0);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int64 | size0 | Size for the first dimension. |
ShortTensor(Int64, Int64)
Creates a 2D tensor of the specified size.
Declaration
public ShortTensor (long size0, long size1);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int64 | size0 | Size for the first dimension. |
| System.Int64 | size1 | Size for the second dimension. |
ShortTensor(Int64, Int64, Int64)
Creates a 3D tensor of the specified size.
Declaration
public ShortTensor (long size0, long size1, long size2);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int64 | size0 | Size for the first dimension. |
| System.Int64 | size1 | Size for the second dimension. |
| System.Int64 | size2 | Size for the third dimension. |
ShortTensor(Int64, Int64, Int64, Int64)
Creates a 4D tensor of the specified size.
Declaration
public ShortTensor (long size0, long size1, long size2, long size3);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int64 | size0 | Size for the first dimension. |
| System.Int64 | size1 | Size for the second dimension. |
| System.Int64 | size2 | Size for the third dimension. |
| System.Int64 | size3 | Size for the fourth dimension. |
Properties
Data
Returns a pointer to the unmanaged data managed by this tensor.
Declaration
public short* Data { get; }
Property Value
| Type | Description |
|---|---|
| System.Int16* | To be added. |
Dimensions
Returns the number of dimensions for this tensor
Declaration
public int Dimensions { get; }
Property Value
| Type | Description |
|---|---|
| System.Int32 | To be added. |
Item(Int64)
Access to element at the specified position in the tensor
Declaration
public short this[long x0] { get; set; }
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int64 | x0 | Index to access. |
Property Value
| Type | Description |
|---|---|
| System.Int16 | To be added. |
Item(Int64, Int64)
Access to element at the specified position in the tensor
Declaration
public short this[long x0, long x1] { get; set; }
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int64 | x0 | Index in the first dimension to access. |
| System.Int64 | x1 | Index in the second dimension to access. |
Property Value
| Type | Description |
|---|---|
| System.Int16 | To be added. |
Item(Int64, Int64, Int64)
Access to element at the specified position in the tensor
Declaration
public short this[long x0, long x1, long x2] { get; set; }
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int64 | x0 | Index in the first dimension to access. |
| System.Int64 | x1 | Index in the second dimension to access. |
| System.Int64 | x2 | Index in the third dimension to access. |
Property Value
| Type | Description |
|---|---|
| System.Int16 | To be added. |
Item(Int64, Int64, Int64, Int64)
Access to element at the specified position in the tensor
Declaration
public short this[long x0, long x1, long x2, long x3] { get; set; }
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int64 | x0 | Index in the first dimension to access. |
| System.Int64 | x1 | Index in the second dimension to access. |
| System.Int64 | x2 | Index in the third dimension to access. |
| System.Int64 | x3 | Index in the fourth dimension to access. |
Property Value
| Type | Description |
|---|---|
| System.Int16 | To be added. |
Shape
Returns the tensor shape, this is an array whose size determines the number of dimensions on the tensor, and each element is the size of the dimension
Declaration
public long[] Shape { get; }
Property Value
| Type | Description |
|---|---|
| System.Int64[] | To be added. |
Remarks
An array of size 0 is used for constants, an array of size 1 is used for single-dimension arrays, where the dimension is the value of the first element. And so on.
Storage
Returns the associated storage for this tensor
Declaration
public TorchSharp.ShortTensor.ShortStorage Storage { get; }
Property Value
| Type | Description |
|---|---|
To be added. |
Methods
Add(Int16)
Performs the Add operation on each element of the tensor with the
Declaration
public TorchSharp.ShortTensor Add (short value);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | value | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
Remarks
If you want to avoid the allocation of a new tensor, you can use the alternative method PytorchSharp.Add(PytorchSharp.ShortTensor, Short, PytorchSharp.Short).
Add(ShortTensor, Int16, ShortTensor)
Performs the Add operation on each element of the source with the provided scalar. The result tensor specified as the last parameters is resized to match the source.
Declaration
public static void Add (TorchSharp.ShortTensor source, short value, TorchSharp.ShortTensor result);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | source | Source tensor on which the operation will take place. |
| System.Int16 | value | The scalar value that the operation uses. |
| ShortTensor | result | The tensor where the result will be placed |
Remarks
For each element in the
AddBMM(Int16, Int16, ShortTensor, ShortTensor)
Performs AddBMM of the tensor with the provided
Declaration
public TorchSharp.ShortTensor AddBMM (short beta, short alpha, TorchSharp.ShortTensor batch1, TorchSharp.ShortTensor batch2);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | beta | Multiplier for this tensor (β). |
| System.Int16 | alpha | Multiplier for batch1xbatch2 (α) |
| ShortTensor | batch1 | the first batch of matrices to be multiplied |
| ShortTensor | batch2 | the second batch of matrices to be multiplied |
Returns
| Type | Description |
|---|---|
| ShortTensor | β mat+α (∑i=0bbatch1i@batch2i) |
Remarks
β mat+α (∑i=0bbatch1i@batch2i)
AddCDiv(Int16, ShortTensor, ShortTensor)
Performs AddCDiv of the tensor with the provided
Declaration
public TorchSharp.ShortTensor AddCDiv (short value, TorchSharp.ShortTensor src1, TorchSharp.ShortTensor src2);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | value | To be added. |
| ShortTensor | src1 | To be added. |
| ShortTensor | src2 | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
AddCMul(Int16, ShortTensor, ShortTensor)
Performs AddCMul of the tensor with the provided
Declaration
public TorchSharp.ShortTensor AddCMul (short value, TorchSharp.ShortTensor src1, TorchSharp.ShortTensor src2);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | value | To be added. |
| ShortTensor | src1 | To be added. |
| ShortTensor | src2 | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
AddMM(Int16, Int16, ShortTensor, ShortTensor)
Performs AddMM of the tensor with the provided
Declaration
public TorchSharp.ShortTensor AddMM (short beta, short alpha, TorchSharp.ShortTensor mat1, TorchSharp.ShortTensor mat2);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | beta | Multiplier for this tensor (β). |
| System.Int16 | alpha | Multiplier for mat1xmat2 (α) |
| ShortTensor | mat1 | First matrix to be multiplied |
| ShortTensor | mat2 | Second matrix to be multiplied |
Returns
| Type | Description |
|---|---|
| ShortTensor | β mat+α (mat1i@mat2i) |
Remarks
β mat+α (mat1i@mat2i)
AddMV(Int16, Int16, ShortTensor, ShortTensor)
Performs AddMV of the tensor with the provided
Declaration
public TorchSharp.ShortTensor AddMV (short beta, short alpha, TorchSharp.ShortTensor mat, TorchSharp.ShortTensor vec);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | beta | Multiplier for this tensor (β). |
| System.Int16 | alpha | Multiplier for matxvec (α) |
| ShortTensor | mat | Matrix to be multiplied |
| ShortTensor | vec | Vector to be multiplied |
Returns
| Type | Description |
|---|---|
| ShortTensor | β tensor+α (mat@vec) |
Remarks
β tensor+α (mat@vec)
AddR(Int16, Int16, ShortTensor, ShortTensor)
Performs AddR of the tensor with the provided
Declaration
public TorchSharp.ShortTensor AddR (short beta, short alpha, TorchSharp.ShortTensor vec1, TorchSharp.ShortTensor vec2);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | beta | Multiplier for this tensor (β). |
| System.Int16 | alpha | Multiplier for vec1xvec2 (α) |
| ShortTensor | vec1 | the first vector of the outer product |
| ShortTensor | vec2 | the second vector of the outer product |
Returns
| Type | Description |
|---|---|
| ShortTensor | β mat+α (vec1⊗vec2) |
Remarks
β mat+α (vec1⊗vec2)
AddScaled(Int16, Int16)
Performs an AddScaled of the tensor with the provided
Declaration
public TorchSharp.ShortTensor AddScaled (short value1, short value2);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | value1 | To be added. |
| System.Int16 | value2 | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
ARange(Int64, Int64, Int64)
Create a range spanning from xmin to xmax, with 'step' between each value.
Declaration
public static TorchSharp.ShortTensor ARange (long xmin, long xmax, long step);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int64 | xmin | The lower bound of the range. |
| System.Int64 | xmax | The upper bound of the range. |
| System.Int64 | step | The value step. |
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
BAddBMM(Int16, Int16, ShortTensor, ShortTensor)
Performs BAddBMM of the tensor with the provided
Declaration
public TorchSharp.ShortTensor BAddBMM (short beta, short alpha, TorchSharp.ShortTensor batch1, TorchSharp.ShortTensor batch2);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | beta | Multiplier for this tensor (β). |
| System.Int16 | alpha | Multiplier for batch1xbatch2 (α) |
| ShortTensor | batch1 | the first batch of matrices to be multiplied |
| ShortTensor | batch2 | the second batch of matrices to be multiplied |
Returns
| Type | Description |
|---|---|
| ShortTensor | β mati+α (batch1i@batch2i) |
Remarks
β mati+α (batch1i@batch2i)
BitAnd(Int16)
Performs the BitAnd operation on each element of the tensor with the
Declaration
public TorchSharp.ShortTensor BitAnd (short value);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | value | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
Remarks
If you want to avoid the allocation of a new tensor, you can use the alternative method PytorchSharp.BitAnd(PytorchSharp.ShortTensor, Short, PytorchSharp.Short).
BitAnd(ShortTensor, Int16, ShortTensor)
Performs the BitAnd operation on each element of the source with the provided scalar. The result tensor specified as the last parameters is resized to match the source.
Declaration
public static void BitAnd (TorchSharp.ShortTensor source, short value, TorchSharp.ShortTensor result);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | source | Source tensor on which the operation will take place. |
| System.Int16 | value | The scalar value that the operation uses. |
| ShortTensor | result | The tensor where the result will be placed |
Remarks
For each element in the
BitOr(Int16)
Performs the BitOr operation on each element of the tensor with the
Declaration
public TorchSharp.ShortTensor BitOr (short value);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | value | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
Remarks
If you want to avoid the allocation of a new tensor, you can use the alternative method PytorchSharp.BitOr(PytorchSharp.ShortTensor, Short, PytorchSharp.Short).
BitOr(ShortTensor, Int16, ShortTensor)
Performs the BitOr operation on each element of the source with the provided scalar. The result tensor specified as the last parameters is resized to match the source.
Declaration
public static void BitOr (TorchSharp.ShortTensor source, short value, TorchSharp.ShortTensor result);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | source | Source tensor on which the operation will take place. |
| System.Int16 | value | The scalar value that the operation uses. |
| ShortTensor | result | The tensor where the result will be placed |
Remarks
For each element in the
BitXor(ShortTensor, Int16, ShortTensor)
Performs the BitXor operation on each element of the source with the provided scalar. The result tensor specified as the last parameters is resized to match the source.
Declaration
public static void BitXor (TorchSharp.ShortTensor source, short value, TorchSharp.ShortTensor result);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | source | Source tensor on which the operation will take place. |
| System.Int16 | value | The scalar value that the operation uses. |
| ShortTensor | result | The tensor where the result will be placed |
Remarks
For each element in the
BitXor(Int16)
Performs the BitXor operation on each element of the tensor with the
Declaration
public TorchSharp.ShortTensor BitXor (short value);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | value | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
Remarks
If you want to avoid the allocation of a new tensor, you can use the alternative method PytorchSharp.BitXor(PytorchSharp.ShortTensor, Short, PytorchSharp.Short).
CAdd(Int16, ShortTensor)
Performs the CAdd operation on each element of the tensor with the
Declaration
public TorchSharp.ShortTensor CAdd (short value, TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | value | To be added. |
| ShortTensor | src | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
CappedRandom(RandomGenerator, Int64)
Populates the tensor with random values from 0 to max, using the provided random source generator.
Declaration
public void CappedRandom (TorchSharp.RandomGenerator source, long max);
Parameters
| Type | Name | Description |
|---|---|---|
| RandomGenerator | source | The random generator source |
| System.Int64 | max | The upper limit for the values to be generated |
CBitAnd(ShortTensor)
Performs an CBitAnd of the tensor with the provided
Declaration
public TorchSharp.ShortTensor CBitAnd (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
CBitOr(ShortTensor)
Performs an CBitOr of the tensor with the provided
Declaration
public TorchSharp.ShortTensor CBitOr (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
CBitXor(ShortTensor)
Performs an CBitXor of the tensor with the provided
Declaration
public TorchSharp.ShortTensor CBitXor (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
CDiv(ShortTensor)
Performs an CDiv of the tensor with the provided
Declaration
public TorchSharp.ShortTensor CDiv (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
CFMod(ShortTensor)
Performs an CFMod of the tensor with the provided
Declaration
public TorchSharp.ShortTensor CFMod (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
Clamp(Int16, Int16)
Performs an Clamp of the tensor with the provided
Declaration
public TorchSharp.ShortTensor Clamp (short value1, short value2);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | value1 | To be added. |
| System.Int16 | value2 | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
Clamp(ShortTensor, Int16, ShortTensor)
Performs the Clamp operation on each element of the source with the provided scalar. The result tensor specified as the last parameters is resized to match the source.
Declaration
public static void Clamp (TorchSharp.ShortTensor source, short value, TorchSharp.ShortTensor result);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | source | Source tensor on which the operation will take place. |
| System.Int16 | value | The scalar value that the operation uses. |
| ShortTensor | result | The tensor where the result will be placed |
Remarks
For each element in the
Clamp(Int16)
Performs the Clamp operation on each element of the tensor with the
Declaration
public TorchSharp.ShortTensor Clamp (short value);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | value | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
Remarks
If you want to avoid the allocation of a new tensor, you can use the alternative method PytorchSharp.Clamp(PytorchSharp.ShortTensor, Short, PytorchSharp.Short).
ClampedRandom(RandomGenerator, Int64, Int64)
Populates the tensor with random values from min to max, using the provided random source generator.
Declaration
public void ClampedRandom (TorchSharp.RandomGenerator source, long min, long max);
Parameters
| Type | Name | Description |
|---|---|---|
| RandomGenerator | source | The random generator source |
| System.Int64 | min | The lower limit for the values to be generated |
| System.Int64 | max | The upper limit for the values to be generated |
Clone()
Returns a deep clone of the tensor
Declaration
public TorchSharp.ShortTensor Clone ();
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
CLShift(ShortTensor)
Performs an CLShift of the tensor with the provided
Declaration
public TorchSharp.ShortTensor CLShift (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
CMax(ShortTensor)
Performs an CMax of the tensor with the provided
Declaration
public TorchSharp.ShortTensor CMax (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
CMaxValue(Int16)
Performs an CMaxValue of the tensor with the provided
Declaration
public TorchSharp.ShortTensor CMaxValue (short src);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
CMin(ShortTensor)
Performs an CMin of the tensor with the provided
Declaration
public TorchSharp.ShortTensor CMin (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
CMinValue(Int16)
Performs an CMinValue of the tensor with the provided
Declaration
public TorchSharp.ShortTensor CMinValue (short src);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
CMul(ShortTensor)
Performs an CMul of the tensor with the provided
Declaration
public TorchSharp.ShortTensor CMul (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
Concatenate(ShortTensor, Int32)
Concatenate tensors along the given dimesion.
Declaration
public TorchSharp.ShortTensor Concatenate (TorchSharp.ShortTensor other, int dimension);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | other | The second tensor. |
| System.Int32 | dimension | The dimension along which to concatenate. |
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
Copy(ShortTensor)
Copies the elements of a tensor into the original tensor. The shape of the tensors must exactly match or an error will be thrown.
Declaration
public void Copy (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | Tensor to copy the data from. |
CopyByte(ByteTensor)
Copies the elements of a byte tensor into the original tensor. The shape of the tensors must exactly match or an error will be thrown.
Declaration
public void CopyByte (TorchSharp.ByteTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ByteTensor | src | Tensor to copy the data from. |
CopyDouble(DoubleTensor)
Copies the elements of a double tensor into the original tensor. The shape of the tensors must exactly match or an error will be thrown.
Declaration
public void CopyDouble (TorchSharp.DoubleTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| DoubleTensor | src | Tensor to copy the data from. |
CopyFloat(FloatTensor)
Copies the elements of a float tensor into the original tensor. The shape of the tensors must exactly match or an error will be thrown.
Declaration
public void CopyFloat (TorchSharp.FloatTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| FloatTensor | src | Tensor to copy the data from. |
CopyInt(IntTensor)
Copies the elements of a int tensor into the original tensor. The shape of the tensors must exactly match or an error will be thrown.
Declaration
public void CopyInt (TorchSharp.IntTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| IntTensor | src | Tensor to copy the data from. |
CopyLong(LongTensor)
Copies the elements of a long tensor into the original tensor. The shape of the tensors must exactly match or an error will be thrown.
Declaration
public void CopyLong (TorchSharp.LongTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| LongTensor | src | Tensor to copy the data from. |
CopyShort(ShortTensor)
Copies the elements of a short tensor into the original tensor. The shape of the tensors must exactly match or an error will be thrown.
Declaration
public void CopyShort (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | Tensor to copy the data from. |
CPow(ShortTensor)
Performs an CPow of the tensor with the provided
Declaration
public TorchSharp.ShortTensor CPow (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
CRemainder(ShortTensor)
Performs an CRemainder of the tensor with the provided
Declaration
public TorchSharp.ShortTensor CRemainder (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
CrossProduct(ShortTensor)
Computes the cross product of two tensors.
Declaration
public TorchSharp.ShortTensor CrossProduct (TorchSharp.ShortTensor other);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | other | The right-hand-side tensor. |
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
CSub(Int16, ShortTensor)
Performs the CSub operation on each element of the tensor with the
Declaration
public TorchSharp.ShortTensor CSub (short value, TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | value | To be added. |
| ShortTensor | src | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
CumulativeProd(Int32)
Computes the cumulative product of all the elements of the tensor along the given dimension.
Declaration
public TorchSharp.ShortTensor CumulativeProd (int dimension);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | dimension | The dimension to process along. |
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
CumulativeSum(Int32)
Computes the cumulative sum of all the elements of the tensor along the given dimension.
Declaration
public TorchSharp.ShortTensor CumulativeSum (int dimension);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | dimension | The dimension to process along. |
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
Diagonal(Int32)
Gets the diagonal of the tensor.
Declaration
public TorchSharp.ShortTensor Diagonal (int k);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | k | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
Dispose()
Releases the tensor and its associated data.
Declaration
public void Dispose ();
Dispose(Boolean)
Implements the .NET Dispose pattern.
Declaration
protected void Dispose (bool disposing);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Boolean | disposing | To be added. |
Div(Int16)
Performs the Div operation on each element of the tensor with the
Declaration
public TorchSharp.ShortTensor Div (short value);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | value | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
Remarks
If you want to avoid the allocation of a new tensor, you can use the alternative method PytorchSharp.Div(PytorchSharp.ShortTensor, Short, PytorchSharp.Short).
Div(ShortTensor, Int16, ShortTensor)
Performs the Div operation on each element of the source with the provided scalar. The result tensor specified as the last parameters is resized to match the source.
Declaration
public static void Div (TorchSharp.ShortTensor source, short value, TorchSharp.ShortTensor result);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | source | Source tensor on which the operation will take place. |
| System.Int16 | value | The scalar value that the operation uses. |
| ShortTensor | result | The tensor where the result will be placed |
Remarks
For each element in the
Dot(ShortTensor)
Returns the tensor product between this tensor and the provided one
Declaration
public long Dot (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| System.Int64 | The dot product |
EqTensor(ShortTensor)
Performs an EqTensor of the tensor with the provided
Declaration
public TorchSharp.ByteTensor EqTensor (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ByteTensor | This returns a new tensor with the same shape as the tensor this operates on. |
EqTensorT(ShortTensor)
Performs an EqTensorT of the tensor with the provided
Declaration
public TorchSharp.ShortTensor EqTensorT (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
Equal(ShortTensor)
Compare the tensor with another for complete equality.
Declaration
public bool Equal (TorchSharp.ShortTensor other);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | other | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| System.Boolean | To be added. |
EqValue(Int16)
Performs an EqValue of the tensor with the provided
Declaration
public TorchSharp.ByteTensor EqValue (short src);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ByteTensor | This returns a new tensor with the same shape as the tensor this operates on. |
EqValueT(Int16)
Performs an EqValueT of the tensor with the provided
Declaration
public TorchSharp.ShortTensor EqValueT (short src);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
Eye(Int64, Int64)
Eye.
Declaration
public static TorchSharp.ShortTensor Eye (long m, long n);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int64 | m | To be added. |
| System.Int64 | n | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
Fill(Int16)
Fills the tensor with the specified value
Declaration
public void Fill (short value);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | value | To be added. |
Finalize()
Finalizer for ~ShortTensor
Declaration
~ShortTensor ();
Fmod(Int16)
Performs the Fmod operation on each element of the tensor with the
Declaration
public TorchSharp.ShortTensor Fmod (short value);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | value | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
Remarks
If you want to avoid the allocation of a new tensor, you can use the alternative method PytorchSharp.Fmod(PytorchSharp.ShortTensor, Short, PytorchSharp.Short).
Fmod(ShortTensor, Int16, ShortTensor)
Performs the Fmod operation on each element of the source with the provided scalar. The result tensor specified as the last parameters is resized to match the source.
Declaration
public static void Fmod (TorchSharp.ShortTensor source, short value, TorchSharp.ShortTensor result);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | source | Source tensor on which the operation will take place. |
| System.Int16 | value | The scalar value that the operation uses. |
| ShortTensor | result | The tensor where the result will be placed |
Remarks
For each element in the
Gather(ShortTensor, Int32, LongTensor)
Gather
Declaration
public void Gather (TorchSharp.ShortTensor src, int dim, TorchSharp.LongTensor index);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | To be added. |
| System.Int32 | dim | To be added. |
| LongTensor | index | Indices of entries to copy. |
Geometric(RandomGenerator, Double)
Populates the tensor with random values from 0 to n, using the provided random source generator.
Declaration
public void Geometric (TorchSharp.RandomGenerator source, double p);
Parameters
| Type | Name | Description |
|---|---|---|
| RandomGenerator | source | The random generator source |
| System.Double | p | To be added. |
GeTensor(ShortTensor)
Performs an GeTensor of the tensor with the provided
Declaration
public TorchSharp.ByteTensor GeTensor (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ByteTensor | This returns a new tensor with the same shape as the tensor this operates on. |
GeTensorT(ShortTensor)
Performs an GeTensorT of the tensor with the provided
Declaration
public TorchSharp.ShortTensor GeTensorT (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
GetTensorDimension(Int32)
Retrieves the size of the specified dimension in the tensor.
Declaration
public long GetTensorDimension (int dim);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | dim | To be added. |
Returns
| Type | Description |
|---|---|
| System.Int64 | To be added. |
GetTensorStride(Int32)
Retrieves the stride of the specified dimension in the tensor.
Declaration
public long GetTensorStride (int dim);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | dim | To be added. |
Returns
| Type | Description |
|---|---|
| System.Int64 | To be added. |
GeValue(Int16)
Performs an GeValue of the tensor with the provided
Declaration
public TorchSharp.ByteTensor GeValue (short src);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ByteTensor | This returns a new tensor with the same shape as the tensor this operates on. |
GeValueT(Int16)
Performs an GeValueT of the tensor with the provided
Declaration
public TorchSharp.ShortTensor GeValueT (short src);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
GtTensor(ShortTensor)
Performs an GtTensor of the tensor with the provided
Declaration
public TorchSharp.ByteTensor GtTensor (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ByteTensor | This returns a new tensor with the same shape as the tensor this operates on. |
GtTensorT(ShortTensor)
Performs an GtTensorT of the tensor with the provided
Declaration
public TorchSharp.ShortTensor GtTensorT (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
GtValue(Int16)
Performs an GtValue of the tensor with the provided
Declaration
public TorchSharp.ByteTensor GtValue (short src);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ByteTensor | This returns a new tensor with the same shape as the tensor this operates on. |
GtValueT(Int16)
Performs an GtValueT of the tensor with the provided
Declaration
public TorchSharp.ShortTensor GtValueT (short src);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
IndexAdd(Int32, LongTensor, ShortTensor)
Adds the elements of tensor into the original tensor by selecting the indices in the order given in index. The shape of tensor must exactly match the elements indexed or an error will be thrown.
Declaration
public void IndexAdd (int dim, TorchSharp.LongTensor index, TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | dim | Dimension to select for the add |
| LongTensor | index | Entries to copy |
| ShortTensor | src | Tensor to copy the data from. |
IndexCopy(Int32, LongTensor, ShortTensor)
Copies the elements of tensor into the original tensor by selecting the indices in the order given in index. The shape of tensor must exactly match the elements indexed or an error will be thrown.
Declaration
public void IndexCopy (int dim, TorchSharp.LongTensor index, TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | dim | Dimension to select for the copy |
| LongTensor | index | Entries to copy |
| ShortTensor | src | Tensor to copy the data from. |
IndexFill(Int32, LongTensor, Int16)
Uses the given value to overwrite the original tensor by selecting the indices in the order given in index. The shape of tensor must exactly match the elements indexed or an error will be thrown.
Declaration
public void IndexFill (int dim, TorchSharp.LongTensor index, short value);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | dim | Dimension to select for the fill |
| LongTensor | index | Entries to copy |
| System.Int16 | value | The value to write. |
IndexSelect(Int32, LongTensor)
Returns a new Tensor which indexes the original Tensor along dimension dim using the entries in index. The returned Tensor has the same number of dimensions as the original Tensor. The returned Tensor does not use the same storage as the original Tensor.
Declaration
public TorchSharp.ShortTensor IndexSelect (int dim, TorchSharp.LongTensor index);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | dim | Dimension to select |
| LongTensor | index | Entries to extract |
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
KthValue(Int64, Int32, Boolean)
Computes the kth value of all the elements of the tensor along the given dimension.
Declaration
public Tuple<TorchSharp.ShortTensor,TorchSharp.LongTensor> KthValue (long k, int dimension, bool keepdim);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int64 | k | The value for 'k' in 'kth'. |
| System.Int32 | dimension | The dimension to process along. |
| System.Boolean | keepdim | true if the reduction dimension should be kept, false otherwise. |
Returns
| Type | Description |
|---|---|
| System.Tuple<ShortTensor,LongTensor> | A tuple containing the values and indices of the kth element of each dimension. |
LERP(ShortTensor, Int16)
LERP
Declaration
public TorchSharp.ShortTensor LERP (TorchSharp.ShortTensor other, short weight);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | other | The right-hand-side operand. |
| System.Int16 | weight | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
LeTensor(ShortTensor)
Performs an LeTensor of the tensor with the provided
Declaration
public TorchSharp.ByteTensor LeTensor (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ByteTensor | This returns a new tensor with the same shape as the tensor this operates on. |
LeTensorT(ShortTensor)
Performs an LeTensorT of the tensor with the provided
Declaration
public TorchSharp.ShortTensor LeTensorT (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
LeValue(Int16)
Performs an LeValue of the tensor with the provided
Declaration
public TorchSharp.ByteTensor LeValue (short src);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ByteTensor | This returns a new tensor with the same shape as the tensor this operates on. |
LeValueT(Int16)
Performs an LeValueT of the tensor with the provided
Declaration
public TorchSharp.ShortTensor LeValueT (short src);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
LShift(Int16)
Performs the LShift operation on each element of the tensor with the
Declaration
public TorchSharp.ShortTensor LShift (short value);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | value | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
Remarks
If you want to avoid the allocation of a new tensor, you can use the alternative method PytorchSharp.LShift(PytorchSharp.ShortTensor, Short, PytorchSharp.Short).
LShift(ShortTensor, Int16, ShortTensor)
Performs the LShift operation on each element of the source with the provided scalar. The result tensor specified as the last parameters is resized to match the source.
Declaration
public static void LShift (TorchSharp.ShortTensor source, short value, TorchSharp.ShortTensor result);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | source | Source tensor on which the operation will take place. |
| System.Int16 | value | The scalar value that the operation uses. |
| ShortTensor | result | The tensor where the result will be placed |
Remarks
For each element in the
LtTensor(ShortTensor)
Performs an LtTensor of the tensor with the provided
Declaration
public TorchSharp.ByteTensor LtTensor (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ByteTensor | This returns a new tensor with the same shape as the tensor this operates on. |
LtTensorT(ShortTensor)
Performs an LtTensorT of the tensor with the provided
Declaration
public TorchSharp.ShortTensor LtTensorT (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
LtValue(Int16)
Performs an LtValue of the tensor with the provided
Declaration
public TorchSharp.ByteTensor LtValue (short src);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ByteTensor | This returns a new tensor with the same shape as the tensor this operates on. |
LtValueT(Int16)
Performs an LtValueT of the tensor with the provided
Declaration
public TorchSharp.ShortTensor LtValueT (short src);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
MaskedCopy(ByteTensor, ShortTensor)
Copies elements from the source tensor to the locations indicated by the mask.
Declaration
public void MaskedCopy (TorchSharp.ByteTensor mask, TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ByteTensor | mask | A byte tensor with values 0 or 1 indicating the locations where in the destination the value should be filled. |
| ShortTensor | src | The source tensor. |
Remarks
There must be at least as many elements in the source tensor as there are 1s in the mask.
MaskedFill(ByteTensor, Int16)
Fills the tensor with the specified value at the locations indicated by the mask.
Declaration
public void MaskedFill (TorchSharp.ByteTensor mask, short value);
Parameters
| Type | Name | Description |
|---|---|---|
| ByteTensor | mask | A byte tensor with values 0 or 1 indicating the locations where the value should be filled. |
| System.Int16 | value | The value to write at the indicated locations. |
MaskedSelect(ByteTensor, ShortTensor)
Copies elements from the source tensor at the locations indicated by the mask.
Declaration
public void MaskedSelect (TorchSharp.ByteTensor mask, TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ByteTensor | mask | A byte tensor with values 0 or 1 indicating the locations where in the source the value should be fetched. |
| ShortTensor | src | The source tensor. |
Remarks
There will be as many elements in the tensor as there are 1s in the mask. There must be at least as many elements in the source tensor as there are 1s in the mask.
Match(ShortTensor, Int16)
Match
Declaration
public TorchSharp.ShortTensor Match (TorchSharp.ShortTensor m2, short gain);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | m2 | To be added. |
| System.Int16 | gain | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
Max(Int32, Boolean)
Computes the max of all the elements of the tensor along the given dimension.
Declaration
public Tuple<TorchSharp.ShortTensor,TorchSharp.LongTensor> Max (int dimension, bool keepdim);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | dimension | The dimension to process along. |
| System.Boolean | keepdim | true if the reduction dimension should be kept, false otherwise. |
Returns
| Type | Description |
|---|---|
| System.Tuple<ShortTensor,LongTensor> | A tuple containing the values and indices of the resulting elements. |
MaxAll()
Returns the maximum value of the elements in the tensor.
Declaration
public short MaxAll ();
Returns
| Type | Description |
|---|---|
| System.Int16 | The maximum value of the tensor. |
MeanAll()
Returns the mean of the elements in the tensor.
Declaration
public long MeanAll ();
Returns
| Type | Description |
|---|---|
| System.Int64 | The mean of the tensor. |
Median(Int32, Boolean)
Computes the median of all the elements of the tensor along the given dimension.
Declaration
public Tuple<TorchSharp.ShortTensor,TorchSharp.LongTensor> Median (int dimension, bool keepdim);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | dimension | The dimension to process along. |
| System.Boolean | keepdim | true if the reduction dimension should be kept, false otherwise. |
Returns
| Type | Description |
|---|---|
| System.Tuple<ShortTensor,LongTensor> | A tuple containing the values and indices of the resulting elements. |
MedianAll()
Returns the median of the elements in the tensor.
Declaration
public short MedianAll ();
Returns
| Type | Description |
|---|---|
| System.Int16 | The median of the tensor. |
Min(Int32, Boolean)
Computes the min of all the elements of the tensor along the given dimension.
Declaration
public Tuple<TorchSharp.ShortTensor,TorchSharp.LongTensor> Min (int dimension, bool keepdim);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | dimension | The dimension to process along. |
| System.Boolean | keepdim | true if the reduction dimension should be kept, false otherwise. |
Returns
| Type | Description |
|---|---|
| System.Tuple<ShortTensor,LongTensor> | A tuple containing the values and indices of the resulting elements. |
MinAll()
Returns the minimum value of the elements in the tensor.
Declaration
public short MinAll ();
Returns
| Type | Description |
|---|---|
| System.Int16 | The minimum value of the tensor. |
Mode(Int32, Boolean)
Computes the mode of all the elements of the tensor along the given dimension.
Declaration
public Tuple<TorchSharp.ShortTensor,TorchSharp.LongTensor> Mode (int dimension, bool keepdim);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | dimension | The dimension to process along. |
| System.Boolean | keepdim | true if the reduction dimension should be kept, false otherwise. |
Returns
| Type | Description |
|---|---|
| System.Tuple<ShortTensor,LongTensor> | A tuple containing the values and indices of the resulting elements. |
Mul(Int16)
Performs the Mul operation on each element of the tensor with the
Declaration
public TorchSharp.ShortTensor Mul (short value);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | value | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
Remarks
If you want to avoid the allocation of a new tensor, you can use the alternative method PytorchSharp.Mul(PytorchSharp.ShortTensor, Short, PytorchSharp.Short).
Mul(ShortTensor, Int16, ShortTensor)
Performs the Mul operation on each element of the source with the provided scalar. The result tensor specified as the last parameters is resized to match the source.
Declaration
public static void Mul (TorchSharp.ShortTensor source, short value, TorchSharp.ShortTensor result);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | source | Source tensor on which the operation will take place. |
| System.Int16 | value | The scalar value that the operation uses. |
| ShortTensor | result | The tensor where the result will be placed |
Remarks
For each element in the
Narrow(Int32, Int64, Int64)
Returns a new Tensor which is a narrowed version of the current one: the dimension dim is narrowed from firstIndexto firstIndex+size-1.
Declaration
public TorchSharp.ShortTensor Narrow (int dim, long firstIndex, long size);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | dim | The dimension to narrow |
| System.Int64 | firstIndex | Initial index to narrow |
| System.Int64 | size | Number of elements |
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
NeTensor(ShortTensor)
Performs an NeTensor of the tensor with the provided
Declaration
public TorchSharp.ByteTensor NeTensor (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ByteTensor | This returns a new tensor with the same shape as the tensor this operates on. |
NeTensorT(ShortTensor)
Performs an NeTensorT of the tensor with the provided
Declaration
public TorchSharp.ShortTensor NeTensorT (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
NeValue(Int16)
Performs an NeValue of the tensor with the provided
Declaration
public TorchSharp.ByteTensor NeValue (short src);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ByteTensor | This returns a new tensor with the same shape as the tensor this operates on. |
NeValueT(Int16)
Performs an NeValueT of the tensor with the provided
Declaration
public TorchSharp.ShortTensor NeValueT (short src);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | src | The right-hand-side operand. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
NewWithStorage1d(IntPtr, Int64, Int64)
Access to element at the specified position in the tensor
Declaration
public TorchSharp.ShortTensor NewWithStorage1d (IntPtr offset, long size, long stride);
Parameters
| Type | Name | Description |
|---|---|---|
| System.IntPtr | offset | Offset within the input storage the storage of the new tensor will start from. |
| System.Int64 | size | Size of the first dimension. |
| System.Int64 | stride | Stride of the first dimension. |
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
NewWithStorage2d(IntPtr, Int64, Int64, Int64, Int64)
Access to element at the specified position in the tensor
Declaration
public TorchSharp.ShortTensor NewWithStorage2d (IntPtr offset, long size0, long stride0, long size1, long stride1);
Parameters
| Type | Name | Description |
|---|---|---|
| System.IntPtr | offset | Offset within the input storage the storage of the new tensor will start from. |
| System.Int64 | size0 | Size of the first dimension. |
| System.Int64 | stride0 | Stride of the first dimension. |
| System.Int64 | size1 | Size of the second dimension. |
| System.Int64 | stride1 | Stride of the second dimension. |
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
NewWithStorage3d(IntPtr, Int64, Int64, Int64, Int64, Int64, Int64)
Access to element at the specified position in the tensor
Declaration
public TorchSharp.ShortTensor NewWithStorage3d (IntPtr offset, long size0, long stride0, long size1, long stride1, long size2, long stride2);
Parameters
| Type | Name | Description |
|---|---|---|
| System.IntPtr | offset | Offset within the input storage the storage of the new tensor will start from. |
| System.Int64 | size0 | Size of the first dimension. |
| System.Int64 | stride0 | Stride of the first dimension. |
| System.Int64 | size1 | Size of the second dimension. |
| System.Int64 | stride1 | Stride of the second dimension. |
| System.Int64 | size2 | Size of the third dimension. |
| System.Int64 | stride2 | Stride of the third dimension. |
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
NewWithStorage4d(IntPtr, Int64, Int64, Int64, Int64, Int64, Int64, Int64, Int64)
Access to element at the specified position in the tensor
Declaration
public TorchSharp.ShortTensor NewWithStorage4d (IntPtr offset, long size0, long stride0, long size1, long stride1, long size2, long stride2, long size3, long stride3);
Parameters
| Type | Name | Description |
|---|---|---|
| System.IntPtr | offset | Offset within the input storage the storage of the new tensor will start from. |
| System.Int64 | size0 | Size of the first dimension. |
| System.Int64 | stride0 | Stride of the first dimension. |
| System.Int64 | size1 | Size of the second dimension. |
| System.Int64 | stride1 | Stride of the second dimension. |
| System.Int64 | size2 | Size of the third dimension. |
| System.Int64 | stride2 | Stride of the third dimension. |
| System.Int64 | size3 | Size of the fourth dimension. |
| System.Int64 | stride3 | Stride of the fourth dimension. |
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
NonZero()
Finds the indices of all non-zero elements.
Declaration
public TorchSharp.LongTensor NonZero ();
Returns
| Type | Description |
|---|---|
| LongTensor | To be added. |
NumElements()
Get the number of elements in the tensor.
Declaration
public long NumElements ();
Returns
| Type | Description |
|---|---|
| System.Int64 | To be added. |
Prod(Int32, Boolean)
Computes the product of all the elements of the tensor along the given dimension.
Declaration
public TorchSharp.ShortTensor Prod (int dimension, bool keepdim);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | dimension | The dimension to process along. |
| System.Boolean | keepdim | true if the reduction dimension should be kept, false otherwise. |
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
ProdAll()
Returns the product of the elements in the tensor.
Declaration
public long ProdAll ();
Returns
| Type | Description |
|---|---|
| System.Int64 | The product of the tensor. |
Put(LongTensor, ShortTensor, Boolean)
Put
Declaration
public void Put (TorchSharp.LongTensor index, TorchSharp.ShortTensor src, bool accumulate);
Parameters
| Type | Name | Description |
|---|---|---|
| LongTensor | index | Indices of entries to copy. |
| ShortTensor | src | To be added. |
| System.Boolean | accumulate | To be added. |
Random(Int64)
Populates the tensor with random values from 0 to n, using a newly initialized Random number geneator.
Declaration
public void Random (long n);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int64 | n | The upper limit for the values to be generated |
Random(RandomGenerator)
Populates the tensor with random values using the provided random source generator.
Declaration
public void Random (TorchSharp.RandomGenerator source);
Parameters
| Type | Name | Description |
|---|---|---|
| RandomGenerator | source | The random generator source |
Random(RandomGenerator, Int64)
Populates the tensor with random values from 0 to n, using the provided random source generator.
Declaration
public void Random (TorchSharp.RandomGenerator source, long n);
Parameters
| Type | Name | Description |
|---|---|---|
| RandomGenerator | source | The random generator source |
| System.Int64 | n | The upper limit for the values to be generated |
RandPerm(RandomGenerator, Int64)
Populates the tensor with random values from 0 to n, using the provided random source generator.
Declaration
public void RandPerm (TorchSharp.RandomGenerator source, long max);
Parameters
| Type | Name | Description |
|---|---|---|
| RandomGenerator | source | The random generator source |
| System.Int64 | max | The upper limit for the values to be generated |
Range(Int64, Int64, Int64)
Create a range spanning from xmin to xmax, with 'step' between each value.
Declaration
public static TorchSharp.ShortTensor Range (long xmin, long xmax, long step);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int64 | xmin | The lower bound of the range. |
| System.Int64 | xmax | The upper bound of the range. |
| System.Int64 | step | The value step. |
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
Remainder(Int16)
Performs the Remainder operation on each element of the tensor with the
Declaration
public TorchSharp.ShortTensor Remainder (short value);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | value | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
Remarks
If you want to avoid the allocation of a new tensor, you can use the alternative method PytorchSharp.Remainder(PytorchSharp.ShortTensor, Short, PytorchSharp.Short).
Remainder(ShortTensor, Int16, ShortTensor)
Performs the Remainder operation on each element of the source with the provided scalar. The result tensor specified as the last parameters is resized to match the source.
Declaration
public static void Remainder (TorchSharp.ShortTensor source, short value, TorchSharp.ShortTensor result);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | source | Source tensor on which the operation will take place. |
| System.Int16 | value | The scalar value that the operation uses. |
| ShortTensor | result | The tensor where the result will be placed |
Remarks
For each element in the
Resize1d(Int64)
Resizes the tensor to be one dimensional with the specified size, the contents of the tensor after this are undetermined.
Declaration
public void Resize1d (long size);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int64 | size | The desired new size for the first dimension of the tensor. |
Resize2d(Int64, Int64)
Resizes the tensor to be two dimensional with the specified size, the contents of the tensor after this are undetermined.
Declaration
public void Resize2d (long size0, long size1);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int64 | size0 | The desired new size for the first dimension of the tensor. |
| System.Int64 | size1 | The desired new size for the second dimension of the tensor. |
Resize3d(Int64, Int64, Int64)
Resizes the tensor to be three dimensional with the specified size, the contents of the tensor after this are undetermined.
Declaration
public void Resize3d (long size0, long size1, long size2);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int64 | size0 | The desired new size for the first dimension of the tensor. |
| System.Int64 | size1 | The desired new size for the second dimension of the tensor. |
| System.Int64 | size2 | The desired new size for the third dimension of the tensor. |
Resize4d(Int64, Int64, Int64, Int64)
Resizes the tensor to be four dimensional with the specified size, the contents of the tensor after this are undetermined.
Declaration
public void Resize4d (long size0, long size1, long size2, long size3);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int64 | size0 | The desired new size for the first dimension of the tensor. |
| System.Int64 | size1 | The desired new size for the second dimension of the tensor. |
| System.Int64 | size2 | The desired new size for the third dimension of the tensor. |
| System.Int64 | size3 | The desired new size for the fourth dimension of the tensor. |
Resize5d(Int64, Int64, Int64, Int64, Int64)
Resizes the tensor to be five dimensional with the specified size, the contents of the tensor after this are undetermined.
Declaration
public void Resize5d (long size0, long size1, long size2, long size3, long size4);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int64 | size0 | The desired new size for the first dimension of the tensor. |
| System.Int64 | size1 | The desired new size for the second dimension of the tensor. |
| System.Int64 | size2 | The desired new size for the third dimension of the tensor. |
| System.Int64 | size3 | The desired new size for the fourth dimension of the tensor. |
| System.Int64 | size4 | The desired new size for the fifth dimension of the tensor. |
ResizeAs(ShortTensor)
Resizes the tensor to match the dimensions of the specified src tensor, the contents of the tensor after this are undetermined.
Declaration
public void ResizeAs (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The source tensor whose shape will be mirrored by this tensor. |
RShift(Int16)
Performs the RShift operation on each element of the tensor with the
Declaration
public TorchSharp.ShortTensor RShift (short value);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | value | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
Remarks
If you want to avoid the allocation of a new tensor, you can use the alternative method PytorchSharp.RShift(PytorchSharp.ShortTensor, Short, PytorchSharp.Short).
RShift(ShortTensor, Int16, ShortTensor)
Performs the RShift operation on each element of the source with the provided scalar. The result tensor specified as the last parameters is resized to match the source.
Declaration
public static void RShift (TorchSharp.ShortTensor source, short value, TorchSharp.ShortTensor result);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | source | Source tensor on which the operation will take place. |
| System.Int16 | value | The scalar value that the operation uses. |
| ShortTensor | result | The tensor where the result will be placed |
Remarks
For each element in the
Scatter(Int32, LongTensor, ShortTensor)
Scatter
Declaration
public void Scatter (int dim, TorchSharp.LongTensor index, TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | dim | To be added. |
| LongTensor | index | Indices of entries to copy. |
| ShortTensor | src | To be added. |
ScatterAdd(Int32, LongTensor, ShortTensor)
ScatterAdd
Declaration
public void ScatterAdd (int dim, TorchSharp.LongTensor index, TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | dim | To be added. |
| LongTensor | index | Indices of entries to copy. |
| ShortTensor | src | To be added. |
ScatterFill(Int32, LongTensor, Int16)
ScatterAdd
Declaration
public void ScatterFill (int dim, TorchSharp.LongTensor index, short value);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | dim | To be added. |
| LongTensor | index | Indices of entries to copy. |
| System.Int16 | value | To be added. |
Select(Int32, Int64)
Returns a new Tensor which is a tensor slice at the given index in the dimension dim.
Declaration
public TorchSharp.ShortTensor Select (int dim, long slideIndex);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | dim | Dimension to select |
| System.Int64 | slideIndex | Beginning of the tensor slice |
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
Remarks
The returned tensor has one less dimension: the dimension dim is removed. As a result, it is not possible to select() on a 1D tensor.
Set(ShortTensor)
The tensor will use the same storage as the provided source, so any changes to that tensor are visible on this one.
Declaration
public void Set (TorchSharp.ShortTensor src);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The source tensor which contains the data.. |
Sign()
Computes the sign of the tensor.
Declaration
public TorchSharp.ShortTensor Sign ();
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
Sort(Int32, Boolean)
Sorts the elements of the tensor along the given dimension.
Declaration
public Tuple<TorchSharp.ShortTensor,TorchSharp.LongTensor> Sort (int dimension, bool descending);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | dimension | The dimension to sort along. |
| System.Boolean | descending | 0 if ascending, 1 if descending. |
Returns
| Type | Description |
|---|---|
| System.Tuple<ShortTensor,LongTensor> | A tuple containing the values and indices of the sorted elements. |
Squeeze()
Squeeze the tensor, i.e. remove all 1-sized dimensions.
Declaration
public void Squeeze ();
Squeeze1d(ShortTensor, Int32)
Squeeze the tensor, by removing the specified dimension.
Declaration
public void Squeeze1d (TorchSharp.ShortTensor src, int dimension);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The source tensor which contains the data. |
| System.Int32 | dimension | The dimension to remove. |
Sub(Int16)
Performs the Sub operation on each element of the tensor with the
Declaration
public TorchSharp.ShortTensor Sub (short value);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | value | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
Remarks
If you want to avoid the allocation of a new tensor, you can use the alternative method PytorchSharp.Sub(PytorchSharp.ShortTensor, Short, PytorchSharp.Short).
Sub(ShortTensor, Int16, ShortTensor)
Performs the Sub operation on each element of the source with the provided scalar. The result tensor specified as the last parameters is resized to match the source.
Declaration
public static void Sub (TorchSharp.ShortTensor source, short value, TorchSharp.ShortTensor result);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | source | Source tensor on which the operation will take place. |
| System.Int16 | value | The scalar value that the operation uses. |
| ShortTensor | result | The tensor where the result will be placed |
Remarks
For each element in the
SubScaled(Int16, Int16)
Performs an SubScaled of the tensor with the provided
Declaration
public TorchSharp.ShortTensor SubScaled (short value1, short value2);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int16 | value1 | To be added. |
| System.Int16 | value2 | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | This returns a new tensor with the same shape as the tensor this operates on. |
Sum(Int32, Boolean)
Computes the sum of all the elements of the tensor along the given dimension.
Declaration
public TorchSharp.ShortTensor Sum (int dimension, bool keepdim);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | dimension | The dimension to process along. |
| System.Boolean | keepdim | true if the reduction dimension should be kept, false otherwise. |
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
SumAll()
Returns the sum of the elements in the tensor.
Declaration
public long SumAll ();
Returns
| Type | Description |
|---|---|
| System.Int64 | The sum of the tensor. |
Take(ShortTensor, LongTensor)
Take
Declaration
public void Take (TorchSharp.ShortTensor src, TorchSharp.LongTensor index);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | To be added. |
| LongTensor | index | Indices of entries to copy. |
TopK(Int64, Int32, Int32, Boolean)
Finds the top k of all the elements of the tensor along the given dimension.
Declaration
public Tuple<TorchSharp.ShortTensor,TorchSharp.LongTensor> TopK (long k, int dim, int dir, bool sorted);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int64 | k | The number of elements to fetch. |
| System.Int32 | dim | The dimension along which to sort and find k elements. |
| System.Int32 | dir | 0 if ascending, 1 if descending. |
| System.Boolean | sorted | 1 if the result should be sorted, 0 if they should keep their original order. |
Returns
| Type | Description |
|---|---|
| System.Tuple<ShortTensor,LongTensor> | A tuple containing the values and indices of the top 'k' elements. |
ToString()
Get a string representation of the tensor.
Declaration
public override string ToString ();
Returns
| Type | Description |
|---|---|
| System.String | To be added. |
Trace()
Computes the trace of the tensor.
Declaration
public long Trace ();
Returns
| Type | Description |
|---|---|
| System.Int64 | To be added. |
Transpose(Int32, Int32)
Returns a tensor where dimensions dim1 and dim2 have been swapped.
Declaration
public TorchSharp.ShortTensor Transpose (int dim1, int dim2);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | dim1 | First dimension |
| System.Int32 | dim2 | Second dimension |
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
TriL(Int64)
Lower triangle.
Declaration
public TorchSharp.ShortTensor TriL (long k);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int64 | k | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
TriU(Int64)
Upper triangle.
Declaration
public TorchSharp.ShortTensor TriU (long k);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int64 | k | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
Unfold(Int32, Int64, Int64)
Returns a tensor which contains all slices of size size in the dimension dim. Step between two slices is given by step.
Declaration
public TorchSharp.ShortTensor Unfold (int dim, long size, long step);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | dim | To be added. |
| System.Int64 | size | To be added. |
| System.Int64 | step | To be added. |
Returns
| Type | Description |
|---|---|
| ShortTensor | To be added. |
Unsqueeze1d(ShortTensor, Int32)
Unsqueeze the tensor, by inserting the specified dimension of size 1.
Declaration
public void Unsqueeze1d (TorchSharp.ShortTensor src, int dimension);
Parameters
| Type | Name | Description |
|---|---|---|
| ShortTensor | src | The source tensor which contains the data. |
| System.Int32 | dimension | The dimension to insert. |
ZeroFill()
Fills the tensor with zeros
Declaration
public void ZeroFill ();


HTML and CSS deal with notions of place, and Javascript adds the notion of time. With HTML and CSS you are organizing your content within a specific structure(the html), and this structure has a specific appearance(the CSS). This creates a static page, that is sturdy within it's space regardless if anyone ever visits it. Javascript adds the experiential quality to a page. It takes in input from the user, and provides dynamic information back. If HTML and CSS create the space, then Javascript creates the notion of how the space exists Now, and adds awareness of the visitor to that space.
This is a beautiful, but problematic, notion as the visitor may not be aware that they are now a part of the experience, nor what part they play or what the intention of the experience may be.
Control flows are the order in which a program executes the commands you've written for it. A program is literal, and consistent: it does exactly as you asked, and interprets it in the exact same way and in the exact same order it's always interpreted it. More practically, this means that when you write out a series of things you'd like your program to do, the exact wording for it is important and the order in which the commands appear is important as both control how the program interprets and experiences its flow.
One way to think of control flows is the rituals you might follow when leaving your house in the morning. For example, before I leave my house I run through a quick flow called "Do I have everything?" that, if run-through successfully, enables me to leave the house. The flow would look like this:
Do I have Everything?
The order of this flow is specific, but in this case it's useful mostly as a memory device. However, as the flows become more involved, the order in which they're run through becomes crucial. Take for example the larger flow of my morning called "Get yourself to Work":
Get Yourself to Work
With this flow, if I decided to do item 2 first, I may find that I leave the house and get to the car but don't have my keys or wallet. Now I can't finish the process (or get back into my house) and will have to run through my error flow of "Swear loudly at nothing then search for an unlocked window."
For loops, they are flows you work through over and over for as long as some certain factor is present. For example, let's say you're in your car to work and want to be a safe driver, so you might run through a "check your mirrors" loop. This loop would be as simple as "For as long as there is a mirror I haven't checked, I'll check it!" So when you run through this loop, it prompts you to check your rearview, your side mirror, and your passenger side mirror and then you can drive safe and secure until it's time to run through the loop again.
In short, control flows and loops are ways we abstract cause and effect to work through what we consider a logical sequence of events. This is (another) reason why diversity in tech is important. If we are abstracting behaviors, and logical sequences, it'll be based on our view of the world. I wouldn't want my above routine to be an actual program required to run, as it assumes I have a car(which I don't). I would need someone to code it who understoodd the need for bus passes too, or know how to write that code myself!
An array is a list of things, while an object is sort of an array where each listed thing has a value. It's sort of like someone giving you a list of books you should read, versus them handing you the actual books.
Functions are straight up magic. With a function, you write down a word and then inscribe it with meaning--literally the things that are done when that word is spoken. You can also add context for that word--things that you would want the spell cast upon or that would affect how the spell is cast. Now that you've defined your spell, you can call upon it throughout your code, where it will consistently perform the magic you asked of it.


My research interests are in several different areas in Statistics. My main focus is on Robust Statistics & Bootstrapping. It can be extremely difficult to find the outliers in a multivariate setting and outliers can ruin the analysis. This led to research about Robust Multivariate Regression, Robust Discriminant Analysis and the one way MANOVA test. Bootstrap tests can be used to weaken assumptions such as a common covariance matrix. I am also interested in statistical learning (also known as machine learning).
“Olsavs: A New Algorithm For Model Selection”, International Journal of Statistics and Probability, March 2023, Hasthika Rupasinghe, Nick Hicks
“Large Sample Bootstrap Prediction Intervals for Variable Selection or Shrinkage Estimators”, Udder Revisions, Hasthika Rupasinghe, Lasanthi Watagoda
“HRLR Regression” RMS: Research in Mathematics & Statistics, Hasthika Rupasinghe, Alan Arnholt, Lasanthi Watagoda.
“Advertisement for Predictive Model Building,” Conference Proceedings, \(32^{nd}\) Annual International Conference on Technology in Collegiate Mathematics (ICTCM), Hasthika Rupasinghe, Alan Arnholt, Lasanthi Watagoda
“An Approximation to the Skew–Normal Distribution,” Vol. 14, 2019, no. 7, 253-261, International Mathematical Forum, Hasthika Rupasinghe, Joel Sanqui, Lasanthi Watagoda.
“Examining the \(n \geq 30\) is Sufficiently Large Caveat for the Sampling Distribution of \(\bar{X}\) to Follow a Normal Distribution,” Bulletin of Statistics and Operations Research, Hasthika Rupasinghe, Alan Arnholt, William Bauldry and Lasanthi Watagoda.
“Sprint Assessment using Machine Learning and a Wearable Accelerometer,”, Journal of Applied Biomechanics, Hasthika Rupasinghe, Reed D. Gurchiek, Lasanthi Watagoda, Ryan S. McGinnis, Alan Arnholt, Herman van Werkhoven, Alan Needle, Jeffrey M. McBride.
“Bootstrapping analogs of the One-Way MANOVA test,”, Communication in Statistics Theory and Methods, Hasthika Rupasinghe, David J Olive.
“A Relationship Between One-Way MANOVA Test Statistic and the Hotelling Lawley Trace Test Statistic,” Vol. 7, No. 6, 2018, International Journal of Statistics and Probability, Hasthika Rupasinghe.
“Bootstrapping analogs of the Hotelling’s \(T^2\) test,” Communications in Statistics Theory and Methods, Oct. 17, 2017 Hasthika Rupasinghe, Lasanthi Watagoda.
“Visualizing and Testing the Multivariate Linear Regression Model,” International Journal of Statistics and Probability, January 22, 2015, Hasthika Rupasinghe, David J Olive, Lasanthi Watagoda.
ICTCM, “A Unified Introduction to Predictive Model Building for Undergraduate Researchers”, July 2020, Contributed Talk
Joint Mathematics Meetings, “A new regularization and variable selection technique - HRLR”, January 2019, Contributed Talk
Joint Mathematics Meetings, “Bootstrapping analogs of the one way MANOVA test”, January 2018, Contributed Talk
Statistics Group Meeting, “Introduction to Overleaf: A collaborative real time LaTeX writing tool”, October 2017, Contributed Talk
A Workshop in Developing Effective Learning Practices — Appalachian State University, September 2017, Attended
Datarobot Workshop in Machine Learning — Appalachian State University, August 2017, Attended
Southern Illinois University, “Bootstrapping analogs of the one way MANOVA test”, April 2017, Invited Talk Presentation Slides
Joint Mathematics Meetings, “Bootstrapping analogs of the Hotteling’s \(T^2\) test”, January 2017, Contributed Talk
Appalachian State University, “Teaching Statistical Inference”, November 2016, Invited Talk
Appalachian State University, “Bootstrapping analogs of the Hotteling’s \(T^2\) test”, November 2016, Contributed Talk
Women in Statistics & Data Science, October 2016, Attended
SIAM Central States Section, “Bootstrapping analogs of the Hotteling’s \(T^2\) test”, October 2016, Contributed Talk
Lloyd Roeling UL Lafayette Conference: Statistics, “Bootstrapping analogs of the Hotteling’s \(T^2\) test”, November 2015, Contributed Talk
International Conference on Robust Rank-Based and Nonparametric Methods, Western Michigan University, “Visualizing and Testing the Multivariate Linear Regression Model”, April 2015, Poster Presentation
Presented a poster at Southern Illinois University, Graduate Research Conference, “Visualizing and Testing the Multivariate Linear Regression Model”, April 2015, Poster Presentation


The touch language defines the interactions you should use when building your app.
It's designed to provide touch-optimized interactions that are learnable and follow the
Windows design principles. Using these interactions makes your app more intuitive and
reliable for users. Each section includes instructions for key actions, and a demo area to
try them for yourself. The corresponding mouse and keyboard actions are also provided.


Turtle Graphics Explorer
Your browser does not support canvas, please upgrade.
Write or load example:
circle
circles
spaghetti
random move in box
fills
rainbow_hair
SQUARE(100);


This maintenance release includes installer and upgrade bug fixes.
OpenGeo Suite changes:
- Bug fixes in installers and when upgrading packages for various platforms (Linux, Windows, OS X affected)
- Documentation bug fixes
- Upgraded to geos 3.4.2
- Postgres Pointcloud is now baked into the Windows install (instead of a checkbox)
- PostGIS libproj grid shift file locations updated on OS X and Windows
- Fixed gdal package availability in python and removed bridj bindings (use JNI)
This maintenance release also includes the following Component upgrades:
GeoServer 2.5.2+
- Fix for rapid concurrent REST API calls to datastores
- JDBCConfig logging initialization fix
- Validation of MetadataLink URL changes via REST API
- GetFeatureInfo engine fixes for unfilled polygons and dashed lines
- Configuration issue fix fot style edits affecting other styles
- DBMS connection leak in some WFS GetFeature with bounds enabled
- Fix for WPS as a workspace-specific service and activity-reporting during asynchronous requests
- Ability to restrict output formats supported by WMS GetMap and GetFeatureInfo
- More docs on how to setup JNDI connection pools
[Reference: GeoServer release notes]
GeoWebCache 1.5.3+
- Styles from non-global workspace virtual services (WMS) can now be used by Embedded GWC
- Layer name field in DiscQuota DB updated to 128 chars
- Fix for NioLock failing to release its memory lock
- Fixed support for STYLE parameter in WMTS
- Fixed unescaped XML characters in capabilities documents
- Exception thrown when calling getCoverageIntersections on a GridSubset
- Fix for unrecognized element gwcConfig on startup
[Reference: GWC release notes]
GeoTools 11.2
- Image mosaic fixes regarding performance, granule harvesting, and heterogeneous mosaic management
- Fixes in XML encoding, in GML and WPS land
- Upgraded imageio-ext dependency to 1.1.10
- Improvements in Grib and NetCDF formats
[Reference: GeoTools release notes]
Components included:
- GeoServer 2.5.2+, rev c7886eb2
- GeoWebCache 1.5.3+, rev 9a50eaa
- GeoTools 11.2, rev 6cc70bb
- PostgreSQL 9.3.4
- PostGIS 2.1.3
- OpenLayers 3.0PRE, rev 7d9e13f3 (same as 4.1)
- QGIS 2.2


I have no personal agenda against action movies in general. If they are entertaining, even in a remotely campy manner, then I will not complain. God only knows that we should not expect much more in this digital, impersonal age. So "Mission: Impossible 2" hardly has much going for it except straightforward action scenes to dazzle and numb the brain. Incredibly, the film is no fun at all - a never-ending trailer for what might look like a cool, sleek action picture that never comes to fruition. It is vapid and joyless - two words that should not be associated with thrill rides.
Ethan Hunt (Tom Cruise), the htoshot superspy from the original, is back, this time trying to prevent a bland villain, Ambrose (Dougray Scott) from buying the antidotes to a deadly virus. From what I gather from the plot, this ambitious nut hopes to gain billions by unleashing this virus upon the world, and since there will be millions of dying, infected people, he will have access to the antidote which he can sell in multitudes. Just sounds like another business proposition that Bill Gates should pursue. The only way to stop this madman is for Hunt to hire a beautiful jewel thief, Nyah Hall (Thandie Newton), to charm the pants off of her former love, Ambrose, so that the IMF team can trace his every move. Sounds like an update of Hitchcock's classic "Notorious" eh? And I assure you that is where the similarities end, since this "M:I 2" possesses not one syllable of greatness from its far superior inspiration.
In fact, this movie is one of the worst sequels in years, embodying absolutely nothing that made the first "Mission: Impossible" a passable success. It is not witty, funny, exciting or engaging at any given moment. For pure excitement, we have an echo of Cruise's famous suspension from a ceiling from the original (which echoed the caper "Topkapi"), and a tense, believable opening plane crash followed by Cruise dangling 2000 feet up from a cliff. Outside of that, director John Woo overdoes the slow-motion technique in his action scenes...even using this technique when Cruise and Newton make goo-goo eyes at each other. I felt like I was watching a commercial for one of those cologne ads.
Cruise slums and preens with not a trace of his personality coming through - he sleepwalks through this movie. Thandie Newton just looks beautiful, a shame considering this is the same actress from "Beloved." Ving Rhames barely reprises his role from the original, and looks just as bored. The villains would barely threaten Adam Sandler. The whole film feels like a bland souffle - it is sour and mechanical. Woo does nothing to enliven the proceedings - he is on automatic air pilot with dozens of shots of motorcycles, kicks, flips in the air, gunfire, oh, and a dove (another Woo trademark). None of this is remotely close to his purely visceral and intoxicating "Face/Off."
Apparently, Tom Cruise fans want him to do more action-oriented/romantic comedy fare, and less of his exalting turns in offbeat films such as "Magnolia." Perhaps this was just a ride to the bank for Cruise, and now he can pursue more challenging roles. My recommended mission, should you choose to accept it, is to avoid this movie at all costs.
For more reviews, check out JERRY AT THE MOVIES at http://buffs.moviething.com/buffs/faust/
E-mail me with any questions, comments or complaints at<EMAIL_ADDRESS>or at<EMAIL_ADDRESS>The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Name
Date
Position
Department
Email
Elliott
01/01/1993
Game Developer
Game Operations
<EMAIL_ADDRESS>Jimmy
12/25/1982
Master Fiddler
Fiddlers
Jimmy.Fiddler@Outlook.com


4 LITTLE GIRLS A film review by Steve Rhodes Copyright 1997 Steve Rhodes
RATING (0 TO ****): *** 1/2
On the morning of September 15, 1963, as Sunday School was in session at the Sixteenth Street Baptist Church in Birmingham, Alabama, an explosion rang out. Long time racially-motivated bomber Robert "Dynamite Bob" Chambliss and a band of his followers had planted a bomb in that church with the intent of inflicting maximum damage.
The civil rights marches were in full-swing in the south and so were the counterinsurgents. These mad bombers that day killed Addie Mae Collins (14), Carol Denise McNair (11), Cynthia Wesley (14) and Carole Rosamond Robertson (14). While Spike Lee was still in film school, he began to plan a movie about the bombing. Over a decade later, he has finally been able to deliver on his dream with a documentary, which he calls simply 4 LITTLE GIRLS, to tell the tragedy of those children's early death.
Spike Lee's publicist sent me an unsolicited press video with the goal of fostering knowledge of the film and building demand that it be shown more widely than it has been those far. Even though it has gotten rave reviews, it has only played in 9 major markets in the United States, missing the Silicon Valley and many other regions of the country. (All of the revenue earned from the theatrical release of the film is being donated to a memorial fund for the 4 girls.)
From Spike Lee's very first movie, SHE'S GOTTA HAVE IT, he has demonstrated fresh and interesting approaches to standard material. Although his DO THE RIGHT THING, for which he won an Academy Award for the writing, is arguably his best known film, his picture MALCOLM X, staring Denzel Washington, remains my personal favorite. Spike Lee's first documentary, 4 LITTLE GIRLS, certainly ranks among his best films.
At the time of the bombing Birmingham was a steel town with a long history of labor violence. In one part of the historic film footage in the movie the Rev. Martin Luther King calls Birmingham the most segregated city in America.
Although much of the South by 1963 had begun to remove some of the more blatant examples of racism, Birmingham still had separate white and colored sections for lunch counters, cabs, restrooms, water fountains, movie seats, bus seats, etc., ad nauseam. The "Commissioner of Public Safety," what a misnomer, was the infamous Bull Connor. Bull was fond of using dogs, billy clubs, fire hoses and even a tank to maintain racial order. These white and colored signs were not to be treated lightly.
Describing this era of insanity, the parents of the slain girls tell their stories in retrospective. Denise's father, Christopher McNair, talks about Denise's childhood. His most vivid and moving recollection is a simple story of woe when he had to tell his hungry daughter that he could not buy her a sandwich because the lunch counter at that store was for whites-only, and it did not have one for coloreds.
It was a time when the moderate whites in Birmingham were just beginning to assert themselves. When a picture of white Birmingham hooligans beating a freedom rider made the front pages of newspapers worldwide, local Birmingham businessmen saw it in a newspaper in Tokyo and said that something had to be done. The film does not ascribe any subsequent actions to these good intentions.
"I say segregation now, segregation tomorrow and segregation forever!" were the notorious words said by Governor George Wallace in his inauguration address that year. From that scandalous scene, Lee cuts to today where an invalid Wallace points to a black man named Al who he says is his best friend and who travels with him all over the globe. Wallace claims that when he was governor he provided free textbooks for black students. In contemporary interviews with African-Americans they express doubts that Wallace ever believed his racist rhetoric. They said he was the nicest person you'd ever want to meet until the cameras were turned on him, and then his inflammatory rhetoric was an expedient.
Starting small but expanding rapidly, the civil rights protests in Birmingham grew into something that threatened the white power structure. The reaction by Bull and his crew was swift and predictable. The protesters were put in jail with hardened prisoners, and even little kids went to jail.
The big event for the movement was the tragedy of the death of the 4 little girls. Their funeral was packed with mourners and reporters from all over the world, who descended on the town to cover their burial. As Walter Cronkite put it, "This was the awakening [for white America.]"
The movie ends with Chambliss's trial a decade and a half after his sickening deed. Still laughing at the cameras, he is convinced that he will escape punishment. The film would have been better served with more details of the trial, particularly the investigation leading up to it. Also, too much footage is devoted to names like Bill Cosby and Ozzie Davis who show up mainly to add star power to the picture. These, however, are minor quibbles.
Lee's powerful film works best in the stock footage from the past for no words can adequately describe what happened then. From images as simple as two drinking fountains, one labeled white and one labeled colored, to ones as dramatic as a church in rubbles, the film shocks the viewers with their country's own history.
4 LITTLE GIRLS runs 1:42. The film is not rated but would be PG for mature themes. The picture would be fine for any child old enough to be interested in its subject matter.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


List of all members.
Public Member Functions
Constructor & Destructor Documentation
Constructs an is_null() touch input event object.
Constructs a touch input event object from the given generic input event.
If the given event is itself is_null() or is not a touch input event, the touch object will be is_null().
Constructs a touch input even from the given parameters.
- Parameters:
-
| [in] | instance | The instance for which this event occurred. |
| [in] | type | A PP_InputEvent_Type identifying the type of input event. |
| [in] | time_stamp | A PP_TimeTicks indicating the time when the event occurred. |
| [in] | modifiers | A bit field combination of the PP_InputEvent_Modifier flags. |
Member Function Documentation
Adds the touch-point to the specified TouchList.
- Returns:
- The TouchPoint in the given list with the given identifier, or an empty TouchPoint if the list does not contain a TouchPoint with that identifier.
- Returns:
- The TouchPoint at the given index of the given list, or an empty TouchPoint if the index is out of range.
- Returns:
- The number of TouchPoints in this TouchList.
The documentation for this class was generated from the following file:


Module
Link
Administration Django
Admin
Forms
Post manually
Author django views generic
Show form custom field parameters
Model managers
Persons managers
Polls
Index manually
Index generic
Upload files
Upload files
Custom validators
Validators list
Used timezone
Timezone list
Used language
Language list
Used logs
Log list
Used send emails
Send email
Environment values
Show env key => values
Used asyncio
Examples used asyncio
Used Rest Framework
Login
Users
Groups
Snippet
View set
@api_view
mixins
generic
Permissions
IsAuthenticatedOrReadOnly
HasAPIKey
Filters
filter and order
custom filter (title_only)
owner filter default
Integration Django Url Filter (https://github.com/miki725/django-url-filter)
Pagination
standar pagination (show 1 item per page)
large pagination (show 2 item per page)
Format
JSON
Elastic search
Book
Search
Filter
Tag
Search
Filter
Swager
Documentation swager API


Main Window¶
The default main window lets you add, edit and delete knob defaults. To open the main window navigate to your menu bar and choose Scripts -> default -> defaults window. The default window will appear:
At the top of the window you can manage your presets. Knob defaults are bundled in preset lists and saved as xml files. The first time you launch default your preset list is called Custom. This is the initial preset list. I have added my personal presets list so you will already have some set up knob defaults. Simply click the import preset button, browse to your default installation, navigate to the ‘presets’ folder and import ‘Simon.xml’. Rename the preset list if needed.
You can create a new list by clicking the new button at the top right. You can also rename and delete a presets list. By creating several preset lists you can easily switch between multiple knob default setups - For instance for different artists. Or for a different show. You can also import and export preset lists and share them with other artists.
In the middle of the window you see a table that shows all knob defaults of the current preset. Here you can edit and delete your knob defaults.
To add a new knob default click the blue add new knobDefault button at the bottom left. The upcoming window will be discussed in the next section.


Lists languages for the specified repository. The value shown for each language is the number of bytes of code written in that language.
GET /repos/:owner/:repo/languages
Status: 200 OK
{ "C": 78769, "Python": 7769 }