/// <summary> /// Sum the squares of each item in the source. /// </summary> /// <param name="source">The source values.</param> /// <returns>The sum of the squares of all items in <paramref name="source"/>.</returns> public static float SumSq(ReadOnlySpan <float> source) { Contracts.AssertNonEmpty(source); if (Avx.IsSupported) { return(AvxIntrinsics.SumSqU(source)); } else if (Sse.IsSupported) { return(SseIntrinsics.SumSqU(source)); } else { float result = 0; for (int i = 0; i < source.Length; i++) { result += source[i] * source[i]; } return(result); } }
/// <summary> /// Sum the square of each item in the source and subtract the mean. /// </summary> /// <param name="mean">The mean value.</param> /// <param name="source">The source values.</param> /// <returns>The sum of all items in <paramref name="source"/> by <paramref name="mean"/>.</returns> public static float SumSq(float mean, ReadOnlySpan <float> source) { Contracts.AssertNonEmpty(source); if (Avx.IsSupported) { return((mean == 0) ? AvxIntrinsics.SumSqU(source) : AvxIntrinsics.SumSqDiffU(mean, source)); } else if (Sse.IsSupported) { return((mean == 0) ? SseIntrinsics.SumSqU(source) : SseIntrinsics.SumSqDiffU(mean, source)); } else { float result = 0; for (int i = 0; i < source.Length; i++) { result += (source[i] - mean) * (source[i] - mean); } return(result); } }
/// <summary> /// Sum the absolute value of each item in the source and subtract the mean. /// </summary> /// <param name="mean">The mean value.</param> /// <param name="source">The source values.</param> /// <returns>The sum of all items by absolute value in <paramref name="source"/> subtracted by <paramref name="mean"/>.</returns> public static float SumAbs(float mean, ReadOnlySpan <float> source) { Contracts.AssertNonEmpty(source); if (Avx.IsSupported) { return((mean == 0) ? AvxIntrinsics.SumAbsU(source) : AvxIntrinsics.SumAbsDiffU(mean, source)); } else if (Sse.IsSupported) { return((mean == 0) ? SseIntrinsics.SumAbsU(source) : SseIntrinsics.SumAbsDiffU(mean, source)); } else { float sum = 0; for (int i = 0; i < source.Length; i++) { sum += Math.Abs(source[i] - mean); } return(sum); } }
public static float SumAbs(ReadOnlySpan <float> source) { Contracts.AssertNonEmpty(source); if (source.Length < MinInputSize || !Sse.IsSupported) { float sum = 0; for (int i = 0; i < source.Length; i++) { sum += Math.Abs(source[i]); } return(sum); } else if (Avx.IsSupported) { return(AvxIntrinsics.SumAbsU(source)); } else { return(SseIntrinsics.SumAbsU(source)); } }
/// <summary> /// Add from a source to a destination. /// </summary> /// <param name="source">The source values.</param> /// <param name="destination">The destination values.</param> /// <param name="count">The count of items.</param> public static void Add(ReadOnlySpan <float> source, Span <float> destination, int count) { Contracts.AssertNonEmpty(source); Contracts.AssertNonEmpty(destination); Contracts.Assert(count > 0); Contracts.Assert(count <= source.Length); Contracts.Assert(count <= destination.Length); if (Avx.IsSupported) { AvxIntrinsics.AddU(source, destination, count); } else if (Sse.IsSupported) { SseIntrinsics.AddU(source, destination, count); } else { for (int i = 0; i < count; i++) { destination[i] += source[i]; } } }
public static void AddScale(float scale, ReadOnlySpan <float> source, Span <float> destination, int count) { Contracts.AssertNonEmpty(source); Contracts.AssertNonEmpty(destination); Contracts.Assert(count > 0); Contracts.Assert(count <= source.Length); Contracts.Assert(count <= destination.Length); if (destination.Length < MinInputSize || !Sse.IsSupported) { for (int i = 0; i < count; i++) { destination[i] += scale * source[i]; } } else if (Avx.IsSupported) { AvxIntrinsics.AddScaleU(scale, source, destination, count); } else { SseIntrinsics.AddScaleU(scale, source, destination, count); } }
public void ManagedAddSUPerf() { SseIntrinsics.AddSU(new Span <float>(src), new Span <int>(idx, 0, IDXLEN), new Span <float>(dst)); }
public void ManagedAddUPerf() { SseIntrinsics.AddU(new Span <float>(src, 0, LEN), new Span <float>(dst, 0, LEN)); }
public void ManagedAddScaleSUPerf() { SseIntrinsics.AddScaleSU(DEFAULT_SCALE, new Span <float>(src), new Span <int>(idx, 0, IDXLEN), new Span <float>(dst)); }
public float MaxAbsDiffU() => SseIntrinsics.MaxAbsDiffU(DefaultScale, new Span <float>(src, 0, Length));
public float MaxAbsU() => SseIntrinsics.MaxAbsU(new Span <float>(src, 0, Length));
public void ManagedSdcaL1UpdateUPerf() { SseIntrinsics.SdcaL1UpdateU(DEFAULT_SCALE, new Span <float>(src, 0, LEN), DEFAULT_SCALE, new Span <float>(dst, 0, LEN), new Span <float>(result, 0, LEN)); }
public float ManagedDotSUPerf() { return(SseIntrinsics.DotSU(new Span <float>(src), new Span <float>(dst), new Span <int>(idx, 0, IDXLEN))); }
public float ManagedMaxAbsUPerf() { return(SseIntrinsics.MaxAbsU(new Span <float>(src, 0, LEN))); }
public void ManagedMulElementWiseUPerf() { SseIntrinsics.MulElementWiseU(new Span <float>(src1, 0, LEN), new Span <float>(src2, 0, LEN), new Span <float>(dst, 0, LEN)); }
public void SdcaL1UpdateSU() => SseIntrinsics.SdcaL1UpdateSU(DefaultScale, IndexLength, src, idx, DefaultScale, dst, result);
public void SdcaL1UpdateU() => SseIntrinsics.SdcaL1UpdateU(DefaultScale, Length, src, DefaultScale, dst, result);
public float Dist2() => SseIntrinsics.Dist2(src, dst, Length);
public float DotSU() => SseIntrinsics.DotSU(src, dst, idx, IndexLength);
public float DotU() => SseIntrinsics.DotU(src, dst, Length);
public float ManagedSumSqUPerf() { return(SseIntrinsics.SumSqU(new Span <float>(src, 0, LEN))); }
/// <summary> /// Multiplies a matrix times a source. /// </summary> /// <param name="transpose"><see langword="true"/> to transpose the matrix; otherwise <see langword="false"/>.</param> /// <param name="matrix">The input matrix.</param> /// <param name="source">The source matrix.</param> /// <param name="destination">The destination matrix.</param> /// <param name="stride">The column stride.</param> public static void MatrixTimesSource(bool transpose, AlignedArray matrix, AlignedArray source, AlignedArray destination, int stride) { Contracts.Assert(matrix.Size == destination.Size * source.Size); Contracts.Assert(stride >= 0); if (Avx.IsSupported) { if (!transpose) { Contracts.Assert(stride <= destination.Size); AvxIntrinsics.MatMul(matrix, source, destination, stride, source.Size); } else { Contracts.Assert(stride <= source.Size); AvxIntrinsics.MatMulTran(matrix, source, destination, destination.Size, stride); } } else if (Sse.IsSupported) { if (!transpose) { Contracts.Assert(stride <= destination.Size); SseIntrinsics.MatMul(matrix, source, destination, stride, source.Size); } else { Contracts.Assert(stride <= source.Size); SseIntrinsics.MatMulTran(matrix, source, destination, destination.Size, stride); } } else { if (!transpose) { Contracts.Assert(stride <= destination.Size); for (int i = 0; i < stride; i++) { float dotProduct = 0; for (int j = 0; j < source.Size; j++) { dotProduct += matrix[i * source.Size + j] * source[j]; } destination[i] = dotProduct; } } else { Contracts.Assert(stride <= source.Size); for (int i = 0; i < destination.Size; i++) { float dotProduct = 0; for (int j = 0; j < stride; j++) { dotProduct += matrix[j * destination.Size + i] * source[j]; } destination[i] = dotProduct; } } } }
public float ManagedMaxAbsDiffUPerf() { return(SseIntrinsics.MaxAbsDiffU(DEFAULT_SCALE, new Span <float>(src, 0, LEN))); }
public void ManagedScaleAddUPerf() { SseIntrinsics.ScaleAddU(DEFAULT_SCALE, DEFAULT_SCALE, new Span <float>(dst, 0, LEN)); }
public float ManagedDist2Perf() { return(SseIntrinsics.Dist2(new Span <float>(src, 0, LEN), new Span <float>(dst, 0, LEN))); }
public float SumSqU() => SseIntrinsics.SumSqU(new Span <float>(src, 0, Length));
public void ManagedSdcaL1UpdateSUPerf() { SseIntrinsics.SdcaL1UpdateSU(DEFAULT_SCALE, new Span <float>(src, 0, IDXLEN), new Span <int>(idx, 0, IDXLEN), DEFAULT_SCALE, new Span <float>(dst), new Span <float>(result)); }
public float SumSqDiffU() => SseIntrinsics.SumSqDiffU(DefaultScale, new Span <float>(src, 0, Length));
public void ManagedAddScaleUPerf() { SseIntrinsics.AddScaleU(DEFAULT_SCALE, new Span <float>(src, 0, LEN), new Span <float>(dst, 0, LEN)); }
public void MulElementWiseU() => SseIntrinsics.MulElementWiseU(src1, src2, dst, Length);