Method Multiply

Namespace

Zyl.VectorTraits

Assembly

VectorTraits.dll

Multiply(Vector<float>, Vector<float>)

Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic: rt[i] := left[i] * right[i].

public static Vector<float> Multiply(Vector<float> left, Vector<float> right)

Parameters

left Vector<float>

The vector to multiply with right (将会与right进行相乘的向量).

right Vector<float>

The vector to add with left (将会与left进行相加的向量).

Returns

Vector<float>

The element-wise product of left and right (left 与 right的各元素乘积).

See Also

Multiply_AcceleratedTypes

Multiply<T>(Vector<T>, Vector<T>)

Multiply(Vector<double>, Vector<double>)

Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic: rt[i] := left[i] * right[i].

public static Vector<double> Multiply(Vector<double> left, Vector<double> right)

Parameters

left Vector<double>

The vector to multiply with right (将会与right进行相乘的向量).

right Vector<double>

The vector to add with left (将会与left进行相加的向量).

Returns

Vector<double>

The element-wise product of left and right (left 与 right的各元素乘积).

See Also

Multiply_AcceleratedTypes

Multiply<T>(Vector<T>, Vector<T>)

Multiply(Vector<sbyte>, Vector<sbyte>)

Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic: rt[i] := left[i] * right[i].

[CLSCompliant(false)]
public static Vector<sbyte> Multiply(Vector<sbyte> left, Vector<sbyte> right)

Parameters

left Vector<sbyte>

The vector to multiply with right (将会与right进行相乘的向量).

right Vector<sbyte>

The vector to add with left (将会与left进行相加的向量).

Returns

Vector<sbyte>

The element-wise product of left and right (left 与 right的各元素乘积).

See Also

Multiply_AcceleratedTypes

Multiply<T>(Vector<T>, Vector<T>)

Multiply(Vector<byte>, Vector<byte>)

Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic: rt[i] := left[i] * right[i].

public static Vector<byte> Multiply(Vector<byte> left, Vector<byte> right)

Parameters

left Vector<byte>

The vector to multiply with right (将会与right进行相乘的向量).

right Vector<byte>

The vector to add with left (将会与left进行相加的向量).

Returns

Vector<byte>

The element-wise product of left and right (left 与 right的各元素乘积).

See Also

Multiply_AcceleratedTypes

Multiply<T>(Vector<T>, Vector<T>)

Multiply(Vector<short>, Vector<short>)

Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic: rt[i] := left[i] * right[i].

public static Vector<short> Multiply(Vector<short> left, Vector<short> right)

Parameters

left Vector<short>

The vector to multiply with right (将会与right进行相乘的向量).

right Vector<short>

The vector to add with left (将会与left进行相加的向量).

Returns

Vector<short>

The element-wise product of left and right (left 与 right的各元素乘积).

See Also

Multiply_AcceleratedTypes

Multiply<T>(Vector<T>, Vector<T>)

Multiply(Vector<ushort>, Vector<ushort>)

Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic: rt[i] := left[i] * right[i].

[CLSCompliant(false)]
public static Vector<ushort> Multiply(Vector<ushort> left, Vector<ushort> right)

Parameters

left Vector<ushort>

The vector to multiply with right (将会与right进行相乘的向量).

right Vector<ushort>

The vector to add with left (将会与left进行相加的向量).

Returns

Vector<ushort>

The element-wise product of left and right (left 与 right的各元素乘积).

See Also

Multiply_AcceleratedTypes

Multiply<T>(Vector<T>, Vector<T>)

Multiply(Vector<int>, Vector<int>)

Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic: rt[i] := left[i] * right[i].

public static Vector<int> Multiply(Vector<int> left, Vector<int> right)

Parameters

left Vector<int>

The vector to multiply with right (将会与right进行相乘的向量).

right Vector<int>

The vector to add with left (将会与left进行相加的向量).

Returns

Vector<int>

The element-wise product of left and right (left 与 right的各元素乘积).

See Also

Multiply_AcceleratedTypes

Multiply<T>(Vector<T>, Vector<T>)

Multiply(Vector<uint>, Vector<uint>)

Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic: rt[i] := left[i] * right[i].

[CLSCompliant(false)]
public static Vector<uint> Multiply(Vector<uint> left, Vector<uint> right)

Parameters

left Vector<uint>

The vector to multiply with right (将会与right进行相乘的向量).

right Vector<uint>

The vector to add with left (将会与left进行相加的向量).

Returns

Vector<uint>

The element-wise product of left and right (left 与 right的各元素乘积).

See Also

Multiply_AcceleratedTypes

Multiply<T>(Vector<T>, Vector<T>)

Multiply(Vector<long>, Vector<long>)

Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic: rt[i] := left[i] * right[i].

public static Vector<long> Multiply(Vector<long> left, Vector<long> right)

Parameters

left Vector<long>

The vector to multiply with right (将会与right进行相乘的向量).

right Vector<long>

The vector to add with left (将会与left进行相加的向量).

Returns

Vector<long>

The element-wise product of left and right (left 与 right的各元素乘积).

See Also

Multiply_AcceleratedTypes

Multiply<T>(Vector<T>, Vector<T>)

Multiply(Vector<ulong>, Vector<ulong>)

Multiplies two vectors to compute their element-wise product (将两个向量相乘来计算它们各元素的积). Mnemonic: rt[i] := left[i] * right[i].

[CLSCompliant(false)]
public static Vector<ulong> Multiply(Vector<ulong> left, Vector<ulong> right)

Parameters

left Vector<ulong>

The vector to multiply with right (将会与right进行相乘的向量).

right Vector<ulong>

The vector to add with left (将会与left进行相加的向量).

Returns

Vector<ulong>

The element-wise product of left and right (left 与 right的各元素乘积).

See Also

Multiply_AcceleratedTypes

Multiply<T>(Vector<T>, Vector<T>)