public SimpleUnaryOpTest__ExtractVector128Int161()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (short)(random.Next(0, short.MaxValue));
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector256 <Int16>, byte>(ref _fld), ref Unsafe.As <Int16, byte>(ref _data[0]), VectorSize);
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (short)(random.Next(0, short.MaxValue));
}
_dataTable = new SimpleUnaryOpTest__DataTable <Int16, Int16>(_data, new Int16[RetElementCount], VectorSize);
}
public SimpleUnaryOpTest__ConvertToVector128Int32UInt16()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (ushort)(random.Next(0, ushort.MaxValue));
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <UInt16>, byte>(ref _fld), ref Unsafe.As <UInt16, byte>(ref _data[0]), (uint)Unsafe.SizeOf <Vector128 <UInt16> >());
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (ushort)(random.Next(0, ushort.MaxValue));
}
_dataTable = new SimpleUnaryOpTest__DataTable <Int32, UInt16>(_data, new Int32[RetElementCount], LargestVectorSize);
}
public SimpleUnaryOpTest__InsertInt326()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (int)0;
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector256 <Int32>, byte>(ref _fld), ref Unsafe.As <Int32, byte>(ref _data[0]), (uint)Unsafe.SizeOf <Vector256 <Int32> >());
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (int)0;
}
_dataTable = new SimpleUnaryOpTest__DataTable <Int32, Int32>(_data, new Int32[RetElementCount], LargestVectorSize);
}
public InsertScalarTest__InsertSByte1()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (sbyte)(random.Next(0, sbyte.MaxValue));
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <SByte>, byte>(ref _fld), ref Unsafe.As <SByte, byte>(ref _data[0]), (uint)Unsafe.SizeOf <Vector128 <SByte> >());
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (sbyte)(random.Next(0, sbyte.MaxValue));
}
_dataTable = new SimpleUnaryOpTest__DataTable <SByte, SByte>(_data, new SByte[RetElementCount], LargestVectorSize);
}
public SimpleUnaryOpTest__BroadcastScalarToVector128Byte()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (byte)(random.Next(0, byte.MaxValue));
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <Byte>, byte>(ref _fld), ref Unsafe.As <Byte, byte>(ref _data[0]), VectorSize);
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (byte)(random.Next(0, byte.MaxValue));
}
_dataTable = new SimpleUnaryOpTest__DataTable <Byte, Byte>(_data, new Byte[RetElementCount], VectorSize);
}
public SimpleUnaryOpTest__ShiftLeftLogicalInt3232()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (int)(random.Next(0, int.MaxValue));
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <Int32>, byte>(ref _fld), ref Unsafe.As <Int32, byte>(ref _data[0]), VectorSize);
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (int)(random.Next(0, int.MaxValue));
}
_dataTable = new SimpleUnaryOpTest__DataTable <Int32, Int32>(_data, new Int32[RetElementCount], VectorSize);
}
public SimpleUnaryOpTest__ShiftRightLogicalUInt6464()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (ulong)(random.Next(0, int.MaxValue));
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector256 <UInt64>, byte>(ref _fld), ref Unsafe.As <UInt64, byte>(ref _data[0]), (uint)Unsafe.SizeOf <Vector256 <UInt64> >());
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (ulong)(random.Next(0, int.MaxValue));
}
_dataTable = new SimpleUnaryOpTest__DataTable <UInt64, UInt64>(_data, new UInt64[RetElementCount], LargestVectorSize);
}
public SimpleUnaryOpTest__ConvertToVector128Int16SByte()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue));
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <SByte>, byte>(ref _fld), ref Unsafe.As <SByte, byte>(ref _data[0]), VectorSize);
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue));
}
_dataTable = new SimpleUnaryOpTest__DataTable <Int16, SByte>(_data, new Int16[RetElementCount], VectorSize);
}
public SimpleUnaryOpTest__InsertUInt16129()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (ushort)0;
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <UInt16>, byte>(ref _fld), ref Unsafe.As <UInt16, byte>(ref _data[0]), (uint)Unsafe.SizeOf <Vector128 <UInt16> >());
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (ushort)0;
}
_dataTable = new SimpleUnaryOpTest__DataTable <UInt16, UInt16>(_data, new UInt16[RetElementCount], LargestVectorSize);
}
public SimpleUnaryOpTest__ExtractInt64129()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (long)(random.Next(0, int.MaxValue));
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <Int64>, byte>(ref _fld), ref Unsafe.As <Int64, byte>(ref _data[0]), VectorSize);
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (long)(random.Next(0, int.MaxValue));
}
_dataTable = new SimpleUnaryOpTest__DataTable <Int64, Int64>(_data, new Int64[RetElementCount], VectorSize);
}
public SimpleUnaryOpTest__InsertSingle0()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (float)0;
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <Single>, byte>(ref _fld), ref Unsafe.As <Single, byte>(ref _data[0]), VectorSize);
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (float)0;
}
_dataTable = new SimpleUnaryOpTest__DataTable <Single, Single>(_data, new Single[RetElementCount], VectorSize);
}
public SimpleUnaryOpTest__RoundToNegativeInfinityDouble()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (double)(random.NextDouble());
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector256 <Double>, byte>(ref _fld), ref Unsafe.As <Double, byte>(ref _data[0]), (uint)Unsafe.SizeOf <Vector256 <Double> >());
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (double)(random.NextDouble());
}
_dataTable = new SimpleUnaryOpTest__DataTable <Double, Double>(_data, new Double[RetElementCount], LargestVectorSize);
}
public ImmUnaryOpTest__ShiftLeftLogical128BitLaneUInt641()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (ulong)8;
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector256 <UInt64>, byte>(ref _fld), ref Unsafe.As <UInt64, byte>(ref _data[0]), (uint)Unsafe.SizeOf <Vector256 <UInt64> >());
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (ulong)8;
}
_dataTable = new SimpleUnaryOpTest__DataTable <UInt64, UInt64>(_data, new UInt64[RetElementCount], LargestVectorSize);
}
public GenericUnaryOpTest__GetLowerHalfInt64()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (long)(random.Next(int.MinValue, int.MaxValue));
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector256 <Int64>, byte>(ref _fld), ref Unsafe.As <Int64, byte>(ref _data[0]), (uint)Unsafe.SizeOf <Vector256 <Int64> >());
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (long)(random.Next(int.MinValue, int.MaxValue));
}
_dataTable = new SimpleUnaryOpTest__DataTable <Int64, Int64>(_data, new Int64[RetElementCount], LargestVectorSize);
}
public SimpleUnaryOpTest__DuplicateEvenIndexedSingle()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (float)(random.NextDouble());
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector256 <Single>, byte>(ref _fld), ref Unsafe.As <Single, byte>(ref _data[0]), (uint)Unsafe.SizeOf <Vector256 <Single> >());
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (float)(random.NextDouble());
}
_dataTable = new SimpleUnaryOpTest__DataTable <Single, Single>(_data, new Single[RetElementCount], LargestVectorSize);
}
public SimpleUnaryOpTest__RoundCurrentDirectionDouble()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (double)(random.NextDouble());
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector256 <Double>, byte>(ref _fld), ref Unsafe.As <Double, byte>(ref _data[0]), VectorSize);
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (double)(random.NextDouble());
}
_dataTable = new SimpleUnaryOpTest__DataTable <Double, Double>(_data, new Double[RetElementCount], VectorSize);
}
public SimpleUnaryOpTest__ShiftLeftLogical128BitLaneInt641()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (long)8;
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector256 <Int64>, byte>(ref _fld), ref Unsafe.As <Int64, byte>(ref _data[0]), VectorSize);
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (long)8;
}
_dataTable = new SimpleUnaryOpTest__DataTable <Int64, Int64>(_data, new Int64[RetElementCount], VectorSize);
}
public SimpleUnaryOpTest__ConvertToVector128Int32WithTruncationDouble()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (double)(random.NextDouble());
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector256 <Double>, byte>(ref _fld), ref Unsafe.As <Double, byte>(ref _data[0]), VectorSize);
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (double)(random.NextDouble());
}
_dataTable = new SimpleUnaryOpTest__DataTable <Int32, Double>(_data, new Int32[RetElementCount], VectorSize);
}
public SimpleUnaryOpTest__RoundToNegativeInfinitySingle()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = TestLibrary.Generator.GetSingle();
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <Single>, byte>(ref _fld), ref Unsafe.As <Single, byte>(ref _data[0]), (uint)Unsafe.SizeOf <Vector128 <Single> >());
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = TestLibrary.Generator.GetSingle();
}
_dataTable = new SimpleUnaryOpTest__DataTable <Single, Single>(_data, new Single[RetElementCount], LargestVectorSize);
}
public SimpleUnaryOpTest__ShiftRightLogical128BitLaneByte1()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (byte)8;
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector256 <Byte>, byte>(ref _fld), ref Unsafe.As <Byte, byte>(ref _data[0]), (uint)Unsafe.SizeOf <Vector256 <Byte> >());
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (byte)8;
}
_dataTable = new SimpleUnaryOpTest__DataTable <Byte, Byte>(_data, new Byte[RetElementCount], LargestVectorSize);
}
public SimpleUnaryOpTest__RoundToPositiveInfinitySingle()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (float)(random.NextDouble());
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector256 <Single>, byte>(ref _fld), ref Unsafe.As <Single, byte>(ref _data[0]), VectorSize);
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (float)(random.NextDouble());
}
_dataTable = new SimpleUnaryOpTest__DataTable <Single, Single>(_data, new Single[RetElementCount], VectorSize);
}
public SimpleUnaryOpTest__CeilingDouble()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = TestLibrary.Generator.GetDouble();
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector256 <Double>, byte>(ref _fld), ref Unsafe.As <Double, byte>(ref _data[0]), (uint)Unsafe.SizeOf <Vector256 <Double> >());
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = TestLibrary.Generator.GetDouble();
}
_dataTable = new SimpleUnaryOpTest__DataTable <Double, Double>(_data, new Double[RetElementCount], LargestVectorSize);
}
public ExtractScalarTest__ExtractInt3222()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (int)(random.Next(0, int.MaxValue));
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector256 <Int32>, byte>(ref _fld), ref Unsafe.As <Int32, byte>(ref _data[0]), (uint)Unsafe.SizeOf <Vector256 <Int32> >());
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (int)(random.Next(0, int.MaxValue));
}
_dataTable = new SimpleUnaryOpTest__DataTable <Int32, Int32>(_data, new Int32[RetElementCount], LargestVectorSize);
}
public SimpleUnaryOpTest__BroadcastScalarToVector128UInt16()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (ushort)(random.Next(0, ushort.MaxValue));
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <UInt16>, byte>(ref _fld), ref Unsafe.As <UInt16, byte>(ref _data[0]), VectorSize);
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (ushort)(random.Next(0, ushort.MaxValue));
}
_dataTable = new SimpleUnaryOpTest__DataTable <UInt16, UInt16>(_data, new UInt16[RetElementCount], VectorSize);
}
public SimpleUnaryOpTest__ExtractByte52()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (byte)(random.Next(0, byte.MaxValue));
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector256 <Byte>, byte>(ref _fld), ref Unsafe.As <Byte, byte>(ref _data[0]), (uint)Unsafe.SizeOf <Vector256 <Byte> >());
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (byte)(random.Next(0, byte.MaxValue));
}
_dataTable = new SimpleUnaryOpTest__DataTable <Byte, Byte>(_data, new Byte[RetElementCount], LargestVectorSize);
}
public SimpleUnaryOpTest__ConvertToVector256Int64UInt32()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (uint)(random.Next(0, int.MaxValue));
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <UInt32>, byte>(ref _fld), ref Unsafe.As <UInt32, byte>(ref _data[0]), 16);
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (uint)(random.Next(0, int.MaxValue));
}
_dataTable = new SimpleUnaryOpTest__DataTable <UInt64, UInt32>(_data, new UInt64[RetElementCount], VectorSize);
}
public SimpleUnaryOpTest__InsertUInt641()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (ulong)0;
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector256 <UInt64>, byte>(ref _fld), ref Unsafe.As <UInt64, byte>(ref _data[0]), VectorSize);
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (ulong)0;
}
_dataTable = new SimpleUnaryOpTest__DataTable <UInt64, UInt64>(_data, new UInt64[RetElementCount], VectorSize);
}
public ImmUnaryOpTest__ShiftRightArithmeticInt161()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (short)(random.Next(0, short.MaxValue));
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector256 <Int16>, byte>(ref _fld), ref Unsafe.As <Int16, byte>(ref _data[0]), (uint)Unsafe.SizeOf <Vector256 <Int16> >());
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (short)(random.Next(0, short.MaxValue));
}
_dataTable = new SimpleUnaryOpTest__DataTable <Int16, Int16>(_data, new Int16[RetElementCount], LargestVectorSize);
}
public ImmUnaryOpTest__ShiftRightLogical128BitLaneInt161()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (short)8;
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <Int16>, byte>(ref _fld), ref Unsafe.As <Int16, byte>(ref _data[0]), (uint)Unsafe.SizeOf <Vector128 <Int16> >());
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (short)8;
}
_dataTable = new SimpleUnaryOpTest__DataTable <Int16, Int16>(_data, new Int16[RetElementCount], LargestVectorSize);
}
public SimpleUnaryOpTest__BroadcastScalarToVector128Int64()
{
Succeeded = true;
var random = new Random();
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (long)(random.Next(0, int.MaxValue));
}
Unsafe.CopyBlockUnaligned(ref Unsafe.As <Vector128 <Int64>, byte>(ref _fld), ref Unsafe.As <Int64, byte>(ref _data[0]), (uint)Unsafe.SizeOf <Vector128 <Int64> >());
for (var i = 0; i < Op1ElementCount; i++)
{
_data[i] = (long)(random.Next(0, int.MaxValue));
}
_dataTable = new SimpleUnaryOpTest__DataTable <Int64, Int64>(_data, new Int64[RetElementCount], LargestVectorSize);
}
