Permalink
f78181b Aug 10, 2017
1 contributor

Users who have contributed to this file

2674 lines (2407 sloc) 107 KB
// Accord Math Library
// The Accord.NET Framework
// http://accord-framework.net
//
// Copyright © César Souza, 2009-2017
// cesarsouza at gmail.com
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
//
// ======================================================================
// This code has been generated by a tool; do not edit manually. Instead,
// edit the T4 template Matrix.Product.tt so this file can be regenerated.
// ======================================================================
namespace Accord.Math
{
using Accord.Math;
using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
[GeneratedCode("Accord.NET T4 Templates", "3.3")]
public static partial class Jagged
{
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(int[] a, int[] b)
{
return Outer(a, b, Jagged.Zeros<int>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(int[] a, double[] b)
{
return Outer(a, b, Jagged.Zeros<double>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static float[][] Outer(int[] a, float[] b)
{
return Outer(a, b, Jagged.Zeros<float>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(double[] a, double[] b)
{
return Outer(a, b, Jagged.Zeros<double>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(double[] a, int[] b)
{
return Outer(a, b, Jagged.Zeros<double>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(double[] a, float[] b)
{
return Outer(a, b, Jagged.Zeros<double>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static float[][] Outer(float[] a, float[] b)
{
return Outer(a, b, Jagged.Zeros<float>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(float[] a, double[] b)
{
return Outer(a, b, Jagged.Zeros<double>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static float[][] Outer(float[] a, int[] b)
{
return Outer(a, b, Jagged.Zeros<float>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static long[][] Outer(long[] a, long[] b)
{
return Outer(a, b, Jagged.Zeros<long>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(long[] a, double[] b)
{
return Outer(a, b, Jagged.Zeros<double>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(long[] a, int[] b)
{
return Outer(a, b, Jagged.Zeros<int>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static float[][] Outer(long[] a, float[] b)
{
return Outer(a, b, Jagged.Zeros<float>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static decimal[][] Outer(decimal[] a, decimal[] b)
{
return Outer(a, b, Jagged.Zeros<decimal>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(decimal[] a, double[] b)
{
return Outer(a, b, Jagged.Zeros<double>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(decimal[] a, int[] b)
{
return Outer(a, b, Jagged.Zeros<int>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static float[][] Outer(decimal[] a, float[] b)
{
return Outer(a, b, Jagged.Zeros<float>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static byte[][] Outer(byte[] a, byte[] b)
{
return Outer(a, b, Jagged.Zeros<byte>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(byte[] a, double[] b)
{
return Outer(a, b, Jagged.Zeros<double>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(byte[] a, int[] b)
{
return Outer(a, b, Jagged.Zeros<int>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static float[][] Outer(byte[] a, float[] b)
{
return Outer(a, b, Jagged.Zeros<float>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static short[][] Outer(short[] a, short[] b)
{
return Outer(a, b, Jagged.Zeros<short>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(short[] a, double[] b)
{
return Outer(a, b, Jagged.Zeros<double>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(short[] a, int[] b)
{
return Outer(a, b, Jagged.Zeros<int>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static float[][] Outer(short[] a, float[] b)
{
return Outer(a, b, Jagged.Zeros<float>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static sbyte[][] Outer(sbyte[] a, sbyte[] b)
{
return Outer(a, b, Jagged.Zeros<sbyte>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(sbyte[] a, double[] b)
{
return Outer(a, b, Jagged.Zeros<double>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(sbyte[] a, int[] b)
{
return Outer(a, b, Jagged.Zeros<int>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static float[][] Outer(sbyte[] a, float[] b)
{
return Outer(a, b, Jagged.Zeros<float>(a.Length, b.Length));
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(int[] a, int[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((int)a[i] * (int)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(int[] a, int[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(int[] a, double[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((int)a[i] * (int)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(int[] a, double[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(int[] a, float[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static float[][] Outer(int[] a, float[] b, float[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (float)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(int[] a, float[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(double[] a, double[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(double[] a, double[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((int)a[i] * (int)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(double[] a, int[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(double[] a, int[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((int)a[i] * (int)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(double[] a, float[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static float[][] Outer(double[] a, float[] b, float[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (float)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(double[] a, float[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static float[][] Outer(float[] a, float[] b, float[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (float)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(float[] a, float[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(float[] a, float[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static float[][] Outer(float[] a, double[] b, float[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (float)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(float[] a, double[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(float[] a, double[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static float[][] Outer(float[] a, int[] b, float[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (float)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(float[] a, int[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(float[] a, int[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static long[][] Outer(long[] a, long[] b, long[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (long)((long)a[i] * (long)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(long[] a, long[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(long[] a, long[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((int)a[i] * (int)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static long[][] Outer(long[] a, double[] b, long[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (long)((long)a[i] * (long)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(long[] a, double[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(long[] a, double[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((int)a[i] * (int)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static long[][] Outer(long[] a, int[] b, long[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (long)((long)a[i] * (long)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(long[] a, int[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((int)a[i] * (int)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(long[] a, int[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static long[][] Outer(long[] a, float[] b, long[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (long)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static float[][] Outer(long[] a, float[] b, float[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (float)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(long[] a, float[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(long[] a, float[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static decimal[][] Outer(decimal[] a, decimal[] b, decimal[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (decimal)((decimal)a[i] * (decimal)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(decimal[] a, decimal[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(decimal[] a, decimal[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((int)a[i] * (int)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static decimal[][] Outer(decimal[] a, double[] b, decimal[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (decimal)((decimal)a[i] * (decimal)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(decimal[] a, double[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(decimal[] a, double[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((int)a[i] * (int)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static decimal[][] Outer(decimal[] a, int[] b, decimal[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (decimal)((decimal)a[i] * (decimal)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(decimal[] a, int[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((int)a[i] * (int)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(decimal[] a, int[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static decimal[][] Outer(decimal[] a, float[] b, decimal[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (decimal)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static float[][] Outer(decimal[] a, float[] b, float[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (float)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(decimal[] a, float[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(decimal[] a, float[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static byte[][] Outer(byte[] a, byte[] b, byte[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (byte)((byte)a[i] * (byte)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(byte[] a, byte[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(byte[] a, byte[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((int)a[i] * (int)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static byte[][] Outer(byte[] a, double[] b, byte[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (byte)((byte)a[i] * (byte)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(byte[] a, double[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(byte[] a, double[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((int)a[i] * (int)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static byte[][] Outer(byte[] a, int[] b, byte[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (byte)((byte)a[i] * (byte)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(byte[] a, int[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((int)a[i] * (int)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(byte[] a, int[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static byte[][] Outer(byte[] a, float[] b, byte[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (byte)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static float[][] Outer(byte[] a, float[] b, float[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (float)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(byte[] a, float[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(byte[] a, float[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static short[][] Outer(short[] a, short[] b, short[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (short)((short)a[i] * (short)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(short[] a, short[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(short[] a, short[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((int)a[i] * (int)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static short[][] Outer(short[] a, double[] b, short[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (short)((short)a[i] * (short)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(short[] a, double[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(short[] a, double[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((int)a[i] * (int)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static short[][] Outer(short[] a, int[] b, short[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (short)((short)a[i] * (short)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(short[] a, int[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((int)a[i] * (int)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(short[] a, int[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static short[][] Outer(short[] a, float[] b, short[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (short)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static float[][] Outer(short[] a, float[] b, float[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (float)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(short[] a, float[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(short[] a, float[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static sbyte[][] Outer(sbyte[] a, sbyte[] b, sbyte[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (sbyte)((sbyte)a[i] * (sbyte)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(sbyte[] a, sbyte[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(sbyte[] a, sbyte[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((int)a[i] * (int)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static sbyte[][] Outer(sbyte[] a, double[] b, sbyte[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (sbyte)((sbyte)a[i] * (sbyte)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(sbyte[] a, double[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(sbyte[] a, double[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((int)a[i] * (int)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static sbyte[][] Outer(sbyte[] a, int[] b, sbyte[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (sbyte)((sbyte)a[i] * (sbyte)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(sbyte[] a, int[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((int)a[i] * (int)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(sbyte[] a, int[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static sbyte[][] Outer(sbyte[] a, float[] b, sbyte[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (sbyte)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static float[][] Outer(sbyte[] a, float[] b, float[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (float)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static double[][] Outer(sbyte[] a, float[] b, double[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (double)((double)a[i] * (double)b[j]);
return result;
}
/// <summary>
/// Gets the outer product (matrix product) between two vectors (a*bT).
/// </summary>
///
/// <remarks>
/// In linear algebra, the outer product typically refers to the tensor
/// product of two vectors. The result of applying the outer product to
/// a pair of vectors is a matrix. The name contrasts with the inner product,
/// which takes as input a pair of vectors and produces a scalar.
/// </remarks>
///
#if NET45 || NET46 || NET462 || NETSTANDARD
[MethodImpl(MethodImplOptions.AggressiveInlining)]
#endif
public static int[][] Outer(sbyte[] a, float[] b, int[][] result)
{
for (int i = 0; i < a.Length; i++)
for (int j = 0; j < b.Length; j++)
result[i][j] = (int)((double)a[i] * (double)b[j]);
return result;
}
}
}