"name": "System.ComponentModel.DataAnnotations.Tests.RangeAttributeTests.Validate_DoubleConversionOverflows_ThrowsOverflowException",
"reason": "https://github.com/dotnet/coreclr/pull/20707"
},
+ {
+ "name": "System.ComponentModel.DataAnnotations.Tests.AssociationAttributeTests.Constructor",
+ "reason": "https://github.com/dotnet/coreclr/pull/22595"
+ },
]
}
},
try
{
- Vector128<bool> result = default(Vector128<bool>).As<bool>();
+ Vector128<bool> result = default(Vector128<bool>).As<bool, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector128<byte> result = default(Vector128<bool>).As<byte>();
+ Vector128<byte> result = default(Vector128<bool>).As<bool, byte>();
}
catch (NotSupportedException)
{
try
{
- Vector128<double> result = default(Vector128<bool>).As<double>();
+ Vector128<double> result = default(Vector128<bool>).As<bool, double>();
}
catch (NotSupportedException)
{
try
{
- Vector128<short> result = default(Vector128<bool>).As<short>();
+ Vector128<short> result = default(Vector128<bool>).As<bool, short>();
}
catch (NotSupportedException)
{
try
{
- Vector128<int> result = default(Vector128<bool>).As<int>();
+ Vector128<int> result = default(Vector128<bool>).As<bool, int>();
}
catch (NotSupportedException)
{
try
{
- Vector128<long> result = default(Vector128<bool>).As<long>();
+ Vector128<long> result = default(Vector128<bool>).As<bool, long>();
}
catch (NotSupportedException)
{
try
{
- Vector128<sbyte> result = default(Vector128<bool>).As<sbyte>();
+ Vector128<sbyte> result = default(Vector128<bool>).As<bool, sbyte>();
}
catch (NotSupportedException)
{
try
{
- Vector128<float> result = default(Vector128<bool>).As<float>();
+ Vector128<float> result = default(Vector128<bool>).As<bool, float>();
}
catch (NotSupportedException)
{
try
{
- Vector128<ushort> result = default(Vector128<bool>).As<ushort>();
+ Vector128<ushort> result = default(Vector128<bool>).As<bool, ushort>();
}
catch (NotSupportedException)
{
try
{
- Vector128<uint> result = default(Vector128<bool>).As<uint>();
+ Vector128<uint> result = default(Vector128<bool>).As<bool, uint>();
}
catch (NotSupportedException)
{
try
{
- Vector128<ulong> result = default(Vector128<bool>).As<ulong>();
+ Vector128<ulong> result = default(Vector128<bool>).As<bool, ulong>();
}
catch (NotSupportedException)
{
try
{
- Vector128<bool> result = default(Vector128<byte>).As<bool>();
+ Vector128<bool> result = default(Vector128<byte>).As<byte, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector128<bool> result = default(Vector128<double>).As<bool>();
+ Vector128<bool> result = default(Vector128<double>).As<double, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector128<bool> result = default(Vector128<short>).As<bool>();
+ Vector128<bool> result = default(Vector128<short>).As<short, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector128<bool> result = default(Vector128<int>).As<bool>();
+ Vector128<bool> result = default(Vector128<int>).As<int, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector128<bool> result = default(Vector128<long>).As<bool>();
+ Vector128<bool> result = default(Vector128<long>).As<long, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector128<bool> result = default(Vector128<sbyte>).As<bool>();
+ Vector128<bool> result = default(Vector128<sbyte>).As<sbyte, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector128<bool> result = default(Vector128<float>).As<bool>();
+ Vector128<bool> result = default(Vector128<float>).As<float, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector128<bool> result = default(Vector128<ushort>).As<bool>();
+ Vector128<bool> result = default(Vector128<ushort>).As<ushort, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector128<bool> result = default(Vector128<uint>).As<bool>();
+ Vector128<bool> result = default(Vector128<uint>).As<uint, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector128<bool> result = default(Vector128<ulong>).As<bool>();
+ Vector128<bool> result = default(Vector128<ulong>).As<ulong, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector256<bool> result = default(Vector256<bool>).As<bool>();
+ Vector256<bool> result = default(Vector256<bool>).As<bool, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector256<byte> result = default(Vector256<bool>).As<byte>();
+ Vector256<byte> result = default(Vector256<bool>).As<bool, byte>();
}
catch (NotSupportedException)
{
try
{
- Vector256<double> result = default(Vector256<bool>).As<double>();
+ Vector256<double> result = default(Vector256<bool>).As<bool, double>();
}
catch (NotSupportedException)
{
try
{
- Vector256<short> result = default(Vector256<bool>).As<short>();
+ Vector256<short> result = default(Vector256<bool>).As<bool, short>();
}
catch (NotSupportedException)
{
try
{
- Vector256<int> result = default(Vector256<bool>).As<int>();
+ Vector256<int> result = default(Vector256<bool>).As<bool, int>();
}
catch (NotSupportedException)
{
try
{
- Vector256<long> result = default(Vector256<bool>).As<long>();
+ Vector256<long> result = default(Vector256<bool>).As<bool, long>();
}
catch (NotSupportedException)
{
try
{
- Vector256<sbyte> result = default(Vector256<bool>).As<sbyte>();
+ Vector256<sbyte> result = default(Vector256<bool>).As<bool, sbyte>();
}
catch (NotSupportedException)
{
try
{
- Vector256<float> result = default(Vector256<bool>).As<float>();
+ Vector256<float> result = default(Vector256<bool>).As<bool, float>();
}
catch (NotSupportedException)
{
try
{
- Vector256<ushort> result = default(Vector256<bool>).As<ushort>();
+ Vector256<ushort> result = default(Vector256<bool>).As<bool, ushort>();
}
catch (NotSupportedException)
{
try
{
- Vector256<uint> result = default(Vector256<bool>).As<uint>();
+ Vector256<uint> result = default(Vector256<bool>).As<bool, uint>();
}
catch (NotSupportedException)
{
try
{
- Vector256<ulong> result = default(Vector256<bool>).As<ulong>();
+ Vector256<ulong> result = default(Vector256<bool>).As<bool, ulong>();
}
catch (NotSupportedException)
{
try
{
- Vector256<bool> result = default(Vector256<byte>).As<bool>();
+ Vector256<bool> result = default(Vector256<byte>).As<byte, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector256<bool> result = default(Vector256<double>).As<bool>();
+ Vector256<bool> result = default(Vector256<double>).As<double, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector256<bool> result = default(Vector256<short>).As<bool>();
+ Vector256<bool> result = default(Vector256<short>).As<short, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector256<bool> result = default(Vector256<int>).As<bool>();
+ Vector256<bool> result = default(Vector256<int>).As<int, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector256<bool> result = default(Vector256<long>).As<bool>();
+ Vector256<bool> result = default(Vector256<long>).As<long, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector256<bool> result = default(Vector256<sbyte>).As<bool>();
+ Vector256<bool> result = default(Vector256<sbyte>).As<sbyte, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector256<bool> result = default(Vector256<float>).As<bool>();
+ Vector256<bool> result = default(Vector256<float>).As<float, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector256<bool> result = default(Vector256<ushort>).As<bool>();
+ Vector256<bool> result = default(Vector256<ushort>).As<ushort, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector256<bool> result = default(Vector256<uint>).As<bool>();
+ Vector256<bool> result = default(Vector256<uint>).As<uint, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector256<bool> result = default(Vector256<ulong>).As<bool>();
+ Vector256<bool> result = default(Vector256<ulong>).As<ulong, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector64<bool> result = default(Vector64<bool>).As<bool>();
+ Vector64<bool> result = default(Vector64<bool>).As<bool, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector64<byte> result = default(Vector64<bool>).As<byte>();
+ Vector64<byte> result = default(Vector64<bool>).As<bool, byte>();
}
catch (NotSupportedException)
{
try
{
- Vector64<double> result = default(Vector64<bool>).As<double>();
+ Vector64<double> result = default(Vector64<bool>).As<bool, double>();
}
catch (NotSupportedException)
{
try
{
- Vector64<short> result = default(Vector64<bool>).As<short>();
+ Vector64<short> result = default(Vector64<bool>).As<bool, short>();
}
catch (NotSupportedException)
{
try
{
- Vector64<int> result = default(Vector64<bool>).As<int>();
+ Vector64<int> result = default(Vector64<bool>).As<bool, int>();
}
catch (NotSupportedException)
{
try
{
- Vector64<long> result = default(Vector64<bool>).As<long>();
+ Vector64<long> result = default(Vector64<bool>).As<bool, long>();
}
catch (NotSupportedException)
{
try
{
- Vector64<sbyte> result = default(Vector64<bool>).As<sbyte>();
+ Vector64<sbyte> result = default(Vector64<bool>).As<bool, sbyte>();
}
catch (NotSupportedException)
{
try
{
- Vector64<float> result = default(Vector64<bool>).As<float>();
+ Vector64<float> result = default(Vector64<bool>).As<bool, float>();
}
catch (NotSupportedException)
{
try
{
- Vector64<ushort> result = default(Vector64<bool>).As<ushort>();
+ Vector64<ushort> result = default(Vector64<bool>).As<bool, ushort>();
}
catch (NotSupportedException)
{
try
{
- Vector64<uint> result = default(Vector64<bool>).As<uint>();
+ Vector64<uint> result = default(Vector64<bool>).As<bool, uint>();
}
catch (NotSupportedException)
{
try
{
- Vector64<ulong> result = default(Vector64<bool>).As<ulong>();
+ Vector64<ulong> result = default(Vector64<bool>).As<bool, ulong>();
}
catch (NotSupportedException)
{
try
{
- Vector64<bool> result = default(Vector64<byte>).As<bool>();
+ Vector64<bool> result = default(Vector64<byte>).As<byte, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector64<bool> result = default(Vector64<double>).As<bool>();
+ Vector64<bool> result = default(Vector64<double>).As<double, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector64<bool> result = default(Vector64<short>).As<bool>();
+ Vector64<bool> result = default(Vector64<short>).As<short, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector64<bool> result = default(Vector64<int>).As<bool>();
+ Vector64<bool> result = default(Vector64<int>).As<int, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector64<bool> result = default(Vector64<long>).As<bool>();
+ Vector64<bool> result = default(Vector64<long>).As<long, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector64<bool> result = default(Vector64<sbyte>).As<bool>();
+ Vector64<bool> result = default(Vector64<sbyte>).As<sbyte, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector64<bool> result = default(Vector64<float>).As<bool>();
+ Vector64<bool> result = default(Vector64<float>).As<float, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector64<bool> result = default(Vector64<ushort>).As<bool>();
+ Vector64<bool> result = default(Vector64<ushort>).As<ushort, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector64<bool> result = default(Vector64<uint>).As<bool>();
+ Vector64<bool> result = default(Vector64<uint>).As<uint, bool>();
}
catch (NotSupportedException)
{
try
{
- Vector64<bool> result = default(Vector64<ulong>).As<bool>();
+ Vector64<bool> result = default(Vector64<ulong>).As<ulong, bool>();
}
catch (NotSupportedException)
{
private static readonly (string templateFileName, Dictionary<string, string> templateData)[] NotSupportedInputs = new []
{
("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64Zero", ["TargetType"] = "Vector64<bool>", ["Source"] = "Vector64<bool>", ["Method"] = "Zero" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsGeneric_Boolean", ["TargetType"] = "Vector64<bool>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64ByteAsGeneric_Boolean", ["TargetType"] = "Vector64<bool>", ["Source"] = "default(Vector64<byte>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64DoubleAsGeneric_Boolean", ["TargetType"] = "Vector64<bool>", ["Source"] = "default(Vector64<double>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64Int16AsGeneric_Boolean", ["TargetType"] = "Vector64<bool>", ["Source"] = "default(Vector64<short>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64Int32AsGeneric_Boolean", ["TargetType"] = "Vector64<bool>", ["Source"] = "default(Vector64<int>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64Int64AsGeneric_Boolean", ["TargetType"] = "Vector64<bool>", ["Source"] = "default(Vector64<long>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64SByteAsGeneric_Boolean", ["TargetType"] = "Vector64<bool>", ["Source"] = "default(Vector64<sbyte>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64SingleAsGeneric_Boolean", ["TargetType"] = "Vector64<bool>", ["Source"] = "default(Vector64<float>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64UInt16AsGeneric_Boolean", ["TargetType"] = "Vector64<bool>", ["Source"] = "default(Vector64<ushort>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64UInt32AsGeneric_Boolean", ["TargetType"] = "Vector64<bool>", ["Source"] = "default(Vector64<uint>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64UInt64AsGeneric_Boolean", ["TargetType"] = "Vector64<bool>", ["Source"] = "default(Vector64<ulong>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsGeneric_Byte", ["TargetType"] = "Vector64<byte>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "As<byte>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsGeneric_Double", ["TargetType"] = "Vector64<double>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "As<double>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsGeneric_Int16", ["TargetType"] = "Vector64<short>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "As<short>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsGeneric_Int32", ["TargetType"] = "Vector64<int>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "As<int>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsGeneric_Int64", ["TargetType"] = "Vector64<long>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "As<long>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsGeneric_SByte", ["TargetType"] = "Vector64<sbyte>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "As<sbyte>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsGeneric_Single", ["TargetType"] = "Vector64<float>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "As<float>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsGeneric_UInt16", ["TargetType"] = "Vector64<ushort>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "As<ushort>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsGeneric_UInt32", ["TargetType"] = "Vector64<uint>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "As<uint>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsGeneric_UInt64", ["TargetType"] = "Vector64<ulong>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "As<ulong>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsGeneric_Boolean", ["TargetType"] = "Vector64<bool>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "As<bool, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64ByteAsGeneric_Boolean", ["TargetType"] = "Vector64<bool>", ["Source"] = "default(Vector64<byte>)", ["Method"] = "As<byte, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64DoubleAsGeneric_Boolean", ["TargetType"] = "Vector64<bool>", ["Source"] = "default(Vector64<double>)", ["Method"] = "As<double, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64Int16AsGeneric_Boolean", ["TargetType"] = "Vector64<bool>", ["Source"] = "default(Vector64<short>)", ["Method"] = "As<short, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64Int32AsGeneric_Boolean", ["TargetType"] = "Vector64<bool>", ["Source"] = "default(Vector64<int>)", ["Method"] = "As<int, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64Int64AsGeneric_Boolean", ["TargetType"] = "Vector64<bool>", ["Source"] = "default(Vector64<long>)", ["Method"] = "As<long, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64SByteAsGeneric_Boolean", ["TargetType"] = "Vector64<bool>", ["Source"] = "default(Vector64<sbyte>)", ["Method"] = "As<sbyte, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64SingleAsGeneric_Boolean", ["TargetType"] = "Vector64<bool>", ["Source"] = "default(Vector64<float>)", ["Method"] = "As<float, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64UInt16AsGeneric_Boolean", ["TargetType"] = "Vector64<bool>", ["Source"] = "default(Vector64<ushort>)", ["Method"] = "As<ushort, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64UInt32AsGeneric_Boolean", ["TargetType"] = "Vector64<bool>", ["Source"] = "default(Vector64<uint>)", ["Method"] = "As<uint, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64UInt64AsGeneric_Boolean", ["TargetType"] = "Vector64<bool>", ["Source"] = "default(Vector64<ulong>)", ["Method"] = "As<ulong, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsGeneric_Byte", ["TargetType"] = "Vector64<byte>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "As<bool, byte>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsGeneric_Double", ["TargetType"] = "Vector64<double>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "As<bool, double>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsGeneric_Int16", ["TargetType"] = "Vector64<short>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "As<bool, short>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsGeneric_Int32", ["TargetType"] = "Vector64<int>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "As<bool, int>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsGeneric_Int64", ["TargetType"] = "Vector64<long>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "As<bool, long>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsGeneric_SByte", ["TargetType"] = "Vector64<sbyte>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "As<bool, sbyte>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsGeneric_Single", ["TargetType"] = "Vector64<float>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "As<bool, float>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsGeneric_UInt16", ["TargetType"] = "Vector64<ushort>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "As<bool, ushort>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsGeneric_UInt32", ["TargetType"] = "Vector64<uint>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "As<bool, uint>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsGeneric_UInt64", ["TargetType"] = "Vector64<ulong>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "As<bool, ulong>()" }),
("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsByte", ["TargetType"] = "Vector64<byte>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "AsByte()" }),
("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsDouble", ["TargetType"] = "Vector64<double>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "AsDouble()" }),
("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64BooleanAsInt16", ["TargetType"] = "Vector64<short>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "AsInt16()" }),
("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector64ToVector128Unsafe", ["TargetType"] = "Vector128<bool>", ["Source"] = "default(Vector64<bool>)", ["Method"] = "ToVector128Unsafe()" }),
("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128Zero", ["TargetType"] = "Vector128<bool>", ["Source"] = "Vector128<bool>", ["Method"] = "Zero" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsGeneric_Boolean", ["TargetType"] = "Vector128<bool>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128ByteAsGeneric_Boolean", ["TargetType"] = "Vector128<bool>", ["Source"] = "default(Vector128<byte>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128DoubleAsGeneric_Boolean", ["TargetType"] = "Vector128<bool>", ["Source"] = "default(Vector128<double>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128Int16AsGeneric_Boolean", ["TargetType"] = "Vector128<bool>", ["Source"] = "default(Vector128<short>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128Int32AsGeneric_Boolean", ["TargetType"] = "Vector128<bool>", ["Source"] = "default(Vector128<int>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128Int64AsGeneric_Boolean", ["TargetType"] = "Vector128<bool>", ["Source"] = "default(Vector128<long>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128SByteAsGeneric_Boolean", ["TargetType"] = "Vector128<bool>", ["Source"] = "default(Vector128<sbyte>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128SingleAsGeneric_Boolean", ["TargetType"] = "Vector128<bool>", ["Source"] = "default(Vector128<float>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128UInt16AsGeneric_Boolean", ["TargetType"] = "Vector128<bool>", ["Source"] = "default(Vector128<ushort>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128UInt32AsGeneric_Boolean", ["TargetType"] = "Vector128<bool>", ["Source"] = "default(Vector128<uint>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128UInt64AsGeneric_Boolean", ["TargetType"] = "Vector128<bool>", ["Source"] = "default(Vector128<ulong>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsGeneric_Byte", ["TargetType"] = "Vector128<byte>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "As<byte>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsGeneric_Double", ["TargetType"] = "Vector128<double>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "As<double>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsGeneric_Int16", ["TargetType"] = "Vector128<short>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "As<short>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsGeneric_Int32", ["TargetType"] = "Vector128<int>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "As<int>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsGeneric_Int64", ["TargetType"] = "Vector128<long>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "As<long>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsGeneric_SByte", ["TargetType"] = "Vector128<sbyte>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "As<sbyte>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsGeneric_Single", ["TargetType"] = "Vector128<float>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "As<float>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsGeneric_UInt16", ["TargetType"] = "Vector128<ushort>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "As<ushort>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsGeneric_UInt32", ["TargetType"] = "Vector128<uint>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "As<uint>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsGeneric_UInt64", ["TargetType"] = "Vector128<ulong>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "As<ulong>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsGeneric_Boolean", ["TargetType"] = "Vector128<bool>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "As<bool, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128ByteAsGeneric_Boolean", ["TargetType"] = "Vector128<bool>", ["Source"] = "default(Vector128<byte>)", ["Method"] = "As<byte, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128DoubleAsGeneric_Boolean", ["TargetType"] = "Vector128<bool>", ["Source"] = "default(Vector128<double>)", ["Method"] = "As<double, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128Int16AsGeneric_Boolean", ["TargetType"] = "Vector128<bool>", ["Source"] = "default(Vector128<short>)", ["Method"] = "As<short, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128Int32AsGeneric_Boolean", ["TargetType"] = "Vector128<bool>", ["Source"] = "default(Vector128<int>)", ["Method"] = "As<int, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128Int64AsGeneric_Boolean", ["TargetType"] = "Vector128<bool>", ["Source"] = "default(Vector128<long>)", ["Method"] = "As<long, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128SByteAsGeneric_Boolean", ["TargetType"] = "Vector128<bool>", ["Source"] = "default(Vector128<sbyte>)", ["Method"] = "As<sbyte, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128SingleAsGeneric_Boolean", ["TargetType"] = "Vector128<bool>", ["Source"] = "default(Vector128<float>)", ["Method"] = "As<float, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128UInt16AsGeneric_Boolean", ["TargetType"] = "Vector128<bool>", ["Source"] = "default(Vector128<ushort>)", ["Method"] = "As<ushort, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128UInt32AsGeneric_Boolean", ["TargetType"] = "Vector128<bool>", ["Source"] = "default(Vector128<uint>)", ["Method"] = "As<uint, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128UInt64AsGeneric_Boolean", ["TargetType"] = "Vector128<bool>", ["Source"] = "default(Vector128<ulong>)", ["Method"] = "As<ulong, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsGeneric_Byte", ["TargetType"] = "Vector128<byte>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "As<bool, byte>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsGeneric_Double", ["TargetType"] = "Vector128<double>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "As<bool, double>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsGeneric_Int16", ["TargetType"] = "Vector128<short>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "As<bool, short>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsGeneric_Int32", ["TargetType"] = "Vector128<int>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "As<bool, int>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsGeneric_Int64", ["TargetType"] = "Vector128<long>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "As<bool, long>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsGeneric_SByte", ["TargetType"] = "Vector128<sbyte>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "As<bool, sbyte>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsGeneric_Single", ["TargetType"] = "Vector128<float>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "As<bool, float>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsGeneric_UInt16", ["TargetType"] = "Vector128<ushort>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "As<bool, ushort>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsGeneric_UInt32", ["TargetType"] = "Vector128<uint>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "As<bool, uint>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsGeneric_UInt64", ["TargetType"] = "Vector128<ulong>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "As<bool, ulong>()" }),
("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsByte", ["TargetType"] = "Vector128<byte>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "AsByte()" }),
("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsDouble", ["TargetType"] = "Vector128<double>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "AsDouble()" }),
("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128BooleanAsInt16", ["TargetType"] = "Vector128<short>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "AsInt16()" }),
("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector128ToVector256Unsafe", ["TargetType"] = "Vector256<bool>", ["Source"] = "default(Vector128<bool>)", ["Method"] = "ToVector256Unsafe()" }),
("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256Zero", ["TargetType"] = "Vector256<bool>", ["Source"] = "Vector256<bool>", ["Method"] = "Zero" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsGeneric_Boolean", ["TargetType"] = "Vector256<bool>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256ByteAsGeneric_Boolean", ["TargetType"] = "Vector256<bool>", ["Source"] = "default(Vector256<byte>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256DoubleAsGeneric_Boolean", ["TargetType"] = "Vector256<bool>", ["Source"] = "default(Vector256<double>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256Int16AsGeneric_Boolean", ["TargetType"] = "Vector256<bool>", ["Source"] = "default(Vector256<short>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256Int32AsGeneric_Boolean", ["TargetType"] = "Vector256<bool>", ["Source"] = "default(Vector256<int>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256Int64AsGeneric_Boolean", ["TargetType"] = "Vector256<bool>", ["Source"] = "default(Vector256<long>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256SByteAsGeneric_Boolean", ["TargetType"] = "Vector256<bool>", ["Source"] = "default(Vector256<sbyte>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256SingleAsGeneric_Boolean", ["TargetType"] = "Vector256<bool>", ["Source"] = "default(Vector256<float>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256UInt16AsGeneric_Boolean", ["TargetType"] = "Vector256<bool>", ["Source"] = "default(Vector256<ushort>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256UInt32AsGeneric_Boolean", ["TargetType"] = "Vector256<bool>", ["Source"] = "default(Vector256<uint>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256UInt64AsGeneric_Boolean", ["TargetType"] = "Vector256<bool>", ["Source"] = "default(Vector256<ulong>)", ["Method"] = "As<bool>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsGeneric_Byte", ["TargetType"] = "Vector256<byte>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "As<byte>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsGeneric_Double", ["TargetType"] = "Vector256<double>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "As<double>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsGeneric_Int16", ["TargetType"] = "Vector256<short>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "As<short>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsGeneric_Int32", ["TargetType"] = "Vector256<int>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "As<int>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsGeneric_Int64", ["TargetType"] = "Vector256<long>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "As<long>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsGeneric_SByte", ["TargetType"] = "Vector256<sbyte>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "As<sbyte>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsGeneric_Single", ["TargetType"] = "Vector256<float>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "As<float>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsGeneric_UInt16", ["TargetType"] = "Vector256<ushort>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "As<ushort>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsGeneric_UInt32", ["TargetType"] = "Vector256<uint>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "As<uint>()" }),
- ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsGeneric_UInt64", ["TargetType"] = "Vector256<ulong>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "As<ulong>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsGeneric_Boolean", ["TargetType"] = "Vector256<bool>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "As<bool, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256ByteAsGeneric_Boolean", ["TargetType"] = "Vector256<bool>", ["Source"] = "default(Vector256<byte>)", ["Method"] = "As<byte, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256DoubleAsGeneric_Boolean", ["TargetType"] = "Vector256<bool>", ["Source"] = "default(Vector256<double>)", ["Method"] = "As<double, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256Int16AsGeneric_Boolean", ["TargetType"] = "Vector256<bool>", ["Source"] = "default(Vector256<short>)", ["Method"] = "As<short, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256Int32AsGeneric_Boolean", ["TargetType"] = "Vector256<bool>", ["Source"] = "default(Vector256<int>)", ["Method"] = "As<int, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256Int64AsGeneric_Boolean", ["TargetType"] = "Vector256<bool>", ["Source"] = "default(Vector256<long>)", ["Method"] = "As<long, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256SByteAsGeneric_Boolean", ["TargetType"] = "Vector256<bool>", ["Source"] = "default(Vector256<sbyte>)", ["Method"] = "As<sbyte, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256SingleAsGeneric_Boolean", ["TargetType"] = "Vector256<bool>", ["Source"] = "default(Vector256<float>)", ["Method"] = "As<float, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256UInt16AsGeneric_Boolean", ["TargetType"] = "Vector256<bool>", ["Source"] = "default(Vector256<ushort>)", ["Method"] = "As<ushort, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256UInt32AsGeneric_Boolean", ["TargetType"] = "Vector256<bool>", ["Source"] = "default(Vector256<uint>)", ["Method"] = "As<uint, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256UInt64AsGeneric_Boolean", ["TargetType"] = "Vector256<bool>", ["Source"] = "default(Vector256<ulong>)", ["Method"] = "As<ulong, bool>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsGeneric_Byte", ["TargetType"] = "Vector256<byte>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "As<bool, byte>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsGeneric_Double", ["TargetType"] = "Vector256<double>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "As<bool, double>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsGeneric_Int16", ["TargetType"] = "Vector256<short>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "As<bool, short>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsGeneric_Int32", ["TargetType"] = "Vector256<int>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "As<bool, int>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsGeneric_Int64", ["TargetType"] = "Vector256<long>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "As<bool, long>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsGeneric_SByte", ["TargetType"] = "Vector256<sbyte>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "As<bool, sbyte>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsGeneric_Single", ["TargetType"] = "Vector256<float>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "As<bool, float>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsGeneric_UInt16", ["TargetType"] = "Vector256<ushort>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "As<bool, ushort>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsGeneric_UInt32", ["TargetType"] = "Vector256<uint>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "As<bool, uint>()" }),
+ ("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsGeneric_UInt64", ["TargetType"] = "Vector256<ulong>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "As<bool, ulong>()" }),
("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsByte", ["TargetType"] = "Vector256<byte>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "AsByte()" }),
("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsDouble", ["TargetType"] = "Vector256<double>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "AsDouble()" }),
("VectorNotSupportedTest.template", new Dictionary<string, string> { ["Isa"] = "NotSupported", ["Name"] = "Vector256BooleanAsInt16", ["TargetType"] = "Vector256<short>", ["Source"] = "default(Vector256<bool>)", ["Method"] = "AsInt16()" }),
{VectorType}<{BaseType}> value;
value = {VectorType}.Create({NextValueOp});
- {VectorType}<byte> byteResult = value.{Method}<byte>();
+ {VectorType}<byte> byteResult = value.{Method}<{BaseType}, byte>();
ValidateResult(byteResult, value);
value = {VectorType}.Create({NextValueOp});
- {VectorType}<double> doubleResult = value.{Method}<double>();
+ {VectorType}<double> doubleResult = value.{Method}<{BaseType}, double>();
ValidateResult(doubleResult, value);
value = {VectorType}.Create({NextValueOp});
- {VectorType}<short> shortResult = value.{Method}<short>();
+ {VectorType}<short> shortResult = value.{Method}<{BaseType}, short>();
ValidateResult(shortResult, value);
value = {VectorType}.Create({NextValueOp});
- {VectorType}<int> intResult = value.{Method}<int>();
+ {VectorType}<int> intResult = value.{Method}<{BaseType}, int>();
ValidateResult(intResult, value);
value = {VectorType}.Create({NextValueOp});
- {VectorType}<long> longResult = value.{Method}<long>();
+ {VectorType}<long> longResult = value.{Method}<{BaseType}, long>();
ValidateResult(longResult, value);
value = {VectorType}.Create({NextValueOp});
- {VectorType}<sbyte> sbyteResult = value.{Method}<sbyte>();
+ {VectorType}<sbyte> sbyteResult = value.{Method}<{BaseType}, sbyte>();
ValidateResult(sbyteResult, value);
value = {VectorType}.Create({NextValueOp});
- {VectorType}<float> floatResult = value.{Method}<float>();
+ {VectorType}<float> floatResult = value.{Method}<{BaseType}, float>();
ValidateResult(floatResult, value);
value = {VectorType}.Create({NextValueOp});
- {VectorType}<ushort> ushortResult = value.{Method}<ushort>();
+ {VectorType}<ushort> ushortResult = value.{Method}<{BaseType}, ushort>();
ValidateResult(ushortResult, value);
value = {VectorType}.Create({NextValueOp});
- {VectorType}<uint> uintResult = value.{Method}<uint>();
+ {VectorType}<uint> uintResult = value.{Method}<{BaseType}, uint>();
ValidateResult(uintResult, value);
value = {VectorType}.Create({NextValueOp});
- {VectorType}<ulong> ulongResult = value.{Method}<ulong>();
+ {VectorType}<ulong> ulongResult = value.{Method}<{BaseType}, ulong>();
ValidateResult(ulongResult, value);
}
value = {VectorType}.Create({NextValueOp});
object byteResult = typeof({VectorType}<{BaseType}>)
- .GetMethod(nameof({VectorType}<{BaseType}>.{Method}Byte), new Type[] { })
+ .GetMethod(nameof({VectorType}.{Method}Byte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult(({VectorType}<byte>)(byteResult), value);
value = {VectorType}.Create({NextValueOp});
object doubleResult = typeof({VectorType}<{BaseType}>)
- .GetMethod(nameof({VectorType}<{BaseType}>.{Method}Double), new Type[] { })
+ .GetMethod(nameof({VectorType}.{Method}Double), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult(({VectorType}<double>)(doubleResult), value);
value = {VectorType}.Create({NextValueOp});
object shortResult = typeof({VectorType}<{BaseType}>)
- .GetMethod(nameof({VectorType}<{BaseType}>.{Method}Int16), new Type[] { })
+ .GetMethod(nameof({VectorType}.{Method}Int16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult(({VectorType}<short>)(shortResult), value);
value = {VectorType}.Create({NextValueOp});
object intResult = typeof({VectorType}<{BaseType}>)
- .GetMethod(nameof({VectorType}<{BaseType}>.{Method}Int32), new Type[] { })
+ .GetMethod(nameof({VectorType}.{Method}Int32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult(({VectorType}<int>)(intResult), value);
value = {VectorType}.Create({NextValueOp});
object longResult = typeof({VectorType}<{BaseType}>)
- .GetMethod(nameof({VectorType}<{BaseType}>.{Method}Int64), new Type[] { })
+ .GetMethod(nameof({VectorType}.{Method}Int64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult(({VectorType}<long>)(longResult), value);
value = {VectorType}.Create({NextValueOp});
object sbyteResult = typeof({VectorType}<{BaseType}>)
- .GetMethod(nameof({VectorType}<{BaseType}>.{Method}SByte), new Type[] { })
+ .GetMethod(nameof({VectorType}.{Method}SByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult(({VectorType}<sbyte>)(sbyteResult), value);
value = {VectorType}.Create({NextValueOp});
object floatResult = typeof({VectorType}<{BaseType}>)
- .GetMethod(nameof({VectorType}<{BaseType}>.{Method}Single), new Type[] { })
+ .GetMethod(nameof({VectorType}.{Method}Single), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult(({VectorType}<float>)(floatResult), value);
value = {VectorType}.Create({NextValueOp});
object ushortResult = typeof({VectorType}<{BaseType}>)
- .GetMethod(nameof({VectorType}<{BaseType}>.{Method}UInt16), new Type[] { })
+ .GetMethod(nameof({VectorType}.{Method}UInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult(({VectorType}<ushort>)(ushortResult), value);
value = {VectorType}.Create({NextValueOp});
object uintResult = typeof({VectorType}<{BaseType}>)
- .GetMethod(nameof({VectorType}<{BaseType}>.{Method}UInt32), new Type[] { })
+ .GetMethod(nameof({VectorType}.{Method}UInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult(({VectorType}<uint>)(uintResult), value);
value = {VectorType}.Create({NextValueOp});
object ulongResult = typeof({VectorType}<{BaseType}>)
- .GetMethod(nameof({VectorType}<{BaseType}>.{Method}UInt64), new Type[] { })
+ .GetMethod(nameof({VectorType}.{Method}UInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult(({VectorType}<ulong>)(ulongResult), value);
}
{VectorType}<{BaseType}> value = {VectorType}.Create({ConsumeValues});
object result = typeof({VectorType}<{BaseType}>)
- .GetMethod(nameof({VectorType}<{BaseType}>.{Method}), new Type[] { })
+ .GetMethod(nameof({VectorType}.{Method}), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult(({TgtVectorType}<{BaseType}>)(result), values, isUnsafe: false);
object unsafeResult = typeof({VectorType}<{BaseType}>)
- .GetMethod(nameof({VectorType}<{BaseType}>.{Method}), new Type[] { })
+ .GetMethod(nameof({VectorType}.{Method}), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult(({TgtVectorType}<{BaseType}>)(unsafeResult), values, isUnsafe: true);
}
try
{
object result = typeof({VectorType}<{BaseType}>)
- .GetMethod(nameof({VectorType}<{BaseType}>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof({VectorType}.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult(({BaseType})(result), values);
}
try
{
object result2 = typeof({VectorType}<{BaseType}>)
- .GetMethod(nameof({VectorType}<{BaseType}>.WithElement), new Type[] { typeof(int), typeof({BaseType}) })
+ .GetMethod(nameof({VectorType}.WithElement), new Type[] { typeof(int), typeof({BaseType}) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult(({VectorType}<{BaseType}>)(result2), values, insertedValue);
}
{VectorType}<{BaseType}> value = {VectorType}.Create({ConsumeValues});
object lowerResult = typeof({VectorType}<{BaseType}>)
- .GetMethod(nameof({VectorType}<{BaseType}>.GetLower), new Type[] { })
+ .GetMethod(nameof({VectorType}.GetLower), new Type[] { })
.Invoke(value, new object[] { });
object upperResult = typeof({VectorType}<{BaseType}>)
- .GetMethod(nameof({VectorType}<{BaseType}>.GetUpper), new Type[] { })
+ .GetMethod(nameof({VectorType}.GetUpper), new Type[] { })
.Invoke(value, new object[] { });
ValidateGetResult(({TgtVectorType}<{BaseType}>)(lowerResult), ({TgtVectorType}<{BaseType}>)(upperResult), values);
object result = typeof({VectorType}<{BaseType}>)
- .GetMethod(nameof({VectorType}<{BaseType}>.WithLower), new Type[] { typeof({TgtVectorType}<{BaseType}>) })
+ .GetMethod(nameof({VectorType}.WithLower), new Type[] { typeof({TgtVectorType}<{BaseType}>) })
.Invoke(value, new object[] { upperResult });
result = typeof({VectorType}<{BaseType}>)
- .GetMethod(nameof({VectorType}<{BaseType}>.WithUpper), new Type[] { typeof({TgtVectorType}<{BaseType}>) })
+ .GetMethod(nameof({VectorType}.WithUpper), new Type[] { typeof({TgtVectorType}<{BaseType}>) })
.Invoke(result, new object[] { lowerResult });
ValidateWithResult(({VectorType}<{BaseType}>)(result), values);
}
{VectorType}<{BaseType}> value = {VectorType}.Create({ConsumeValues});
object result = typeof({VectorType}<{BaseType}>)
- .GetMethod(nameof({VectorType}<{BaseType}>.{Method}), new Type[] { })
+ .GetMethod(nameof({VectorType}.{Method}), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult(({BaseType})(result), values);
Vector128<Byte> value;
value = Vector128.Create(TestLibrary.Generator.GetByte());
- Vector128<byte> byteResult = value.As<byte>();
+ Vector128<byte> byteResult = value.As<Byte, byte>();
ValidateResult(byteResult, value);
value = Vector128.Create(TestLibrary.Generator.GetByte());
- Vector128<double> doubleResult = value.As<double>();
+ Vector128<double> doubleResult = value.As<Byte, double>();
ValidateResult(doubleResult, value);
value = Vector128.Create(TestLibrary.Generator.GetByte());
- Vector128<short> shortResult = value.As<short>();
+ Vector128<short> shortResult = value.As<Byte, short>();
ValidateResult(shortResult, value);
value = Vector128.Create(TestLibrary.Generator.GetByte());
- Vector128<int> intResult = value.As<int>();
+ Vector128<int> intResult = value.As<Byte, int>();
ValidateResult(intResult, value);
value = Vector128.Create(TestLibrary.Generator.GetByte());
- Vector128<long> longResult = value.As<long>();
+ Vector128<long> longResult = value.As<Byte, long>();
ValidateResult(longResult, value);
value = Vector128.Create(TestLibrary.Generator.GetByte());
- Vector128<sbyte> sbyteResult = value.As<sbyte>();
+ Vector128<sbyte> sbyteResult = value.As<Byte, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector128.Create(TestLibrary.Generator.GetByte());
- Vector128<float> floatResult = value.As<float>();
+ Vector128<float> floatResult = value.As<Byte, float>();
ValidateResult(floatResult, value);
value = Vector128.Create(TestLibrary.Generator.GetByte());
- Vector128<ushort> ushortResult = value.As<ushort>();
+ Vector128<ushort> ushortResult = value.As<Byte, ushort>();
ValidateResult(ushortResult, value);
value = Vector128.Create(TestLibrary.Generator.GetByte());
- Vector128<uint> uintResult = value.As<uint>();
+ Vector128<uint> uintResult = value.As<Byte, uint>();
ValidateResult(uintResult, value);
value = Vector128.Create(TestLibrary.Generator.GetByte());
- Vector128<ulong> ulongResult = value.As<ulong>();
+ Vector128<ulong> ulongResult = value.As<Byte, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector128.Create(TestLibrary.Generator.GetByte());
object byteResult = typeof(Vector128<Byte>)
- .GetMethod(nameof(Vector128<Byte>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector128.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<byte>)(byteResult), value);
value = Vector128.Create(TestLibrary.Generator.GetByte());
object doubleResult = typeof(Vector128<Byte>)
- .GetMethod(nameof(Vector128<Byte>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector128.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<double>)(doubleResult), value);
value = Vector128.Create(TestLibrary.Generator.GetByte());
object shortResult = typeof(Vector128<Byte>)
- .GetMethod(nameof(Vector128<Byte>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<short>)(shortResult), value);
value = Vector128.Create(TestLibrary.Generator.GetByte());
object intResult = typeof(Vector128<Byte>)
- .GetMethod(nameof(Vector128<Byte>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<int>)(intResult), value);
value = Vector128.Create(TestLibrary.Generator.GetByte());
object longResult = typeof(Vector128<Byte>)
- .GetMethod(nameof(Vector128<Byte>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<long>)(longResult), value);
value = Vector128.Create(TestLibrary.Generator.GetByte());
object sbyteResult = typeof(Vector128<Byte>)
- .GetMethod(nameof(Vector128<Byte>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector128.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<sbyte>)(sbyteResult), value);
value = Vector128.Create(TestLibrary.Generator.GetByte());
object floatResult = typeof(Vector128<Byte>)
- .GetMethod(nameof(Vector128<Byte>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector128.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<float>)(floatResult), value);
value = Vector128.Create(TestLibrary.Generator.GetByte());
object ushortResult = typeof(Vector128<Byte>)
- .GetMethod(nameof(Vector128<Byte>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<ushort>)(ushortResult), value);
value = Vector128.Create(TestLibrary.Generator.GetByte());
object uintResult = typeof(Vector128<Byte>)
- .GetMethod(nameof(Vector128<Byte>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<uint>)(uintResult), value);
value = Vector128.Create(TestLibrary.Generator.GetByte());
object ulongResult = typeof(Vector128<Byte>)
- .GetMethod(nameof(Vector128<Byte>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<ulong>)(ulongResult), value);
}
Vector128<Double> value;
value = Vector128.Create(TestLibrary.Generator.GetDouble());
- Vector128<byte> byteResult = value.As<byte>();
+ Vector128<byte> byteResult = value.As<Double, byte>();
ValidateResult(byteResult, value);
value = Vector128.Create(TestLibrary.Generator.GetDouble());
- Vector128<double> doubleResult = value.As<double>();
+ Vector128<double> doubleResult = value.As<Double, double>();
ValidateResult(doubleResult, value);
value = Vector128.Create(TestLibrary.Generator.GetDouble());
- Vector128<short> shortResult = value.As<short>();
+ Vector128<short> shortResult = value.As<Double, short>();
ValidateResult(shortResult, value);
value = Vector128.Create(TestLibrary.Generator.GetDouble());
- Vector128<int> intResult = value.As<int>();
+ Vector128<int> intResult = value.As<Double, int>();
ValidateResult(intResult, value);
value = Vector128.Create(TestLibrary.Generator.GetDouble());
- Vector128<long> longResult = value.As<long>();
+ Vector128<long> longResult = value.As<Double, long>();
ValidateResult(longResult, value);
value = Vector128.Create(TestLibrary.Generator.GetDouble());
- Vector128<sbyte> sbyteResult = value.As<sbyte>();
+ Vector128<sbyte> sbyteResult = value.As<Double, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector128.Create(TestLibrary.Generator.GetDouble());
- Vector128<float> floatResult = value.As<float>();
+ Vector128<float> floatResult = value.As<Double, float>();
ValidateResult(floatResult, value);
value = Vector128.Create(TestLibrary.Generator.GetDouble());
- Vector128<ushort> ushortResult = value.As<ushort>();
+ Vector128<ushort> ushortResult = value.As<Double, ushort>();
ValidateResult(ushortResult, value);
value = Vector128.Create(TestLibrary.Generator.GetDouble());
- Vector128<uint> uintResult = value.As<uint>();
+ Vector128<uint> uintResult = value.As<Double, uint>();
ValidateResult(uintResult, value);
value = Vector128.Create(TestLibrary.Generator.GetDouble());
- Vector128<ulong> ulongResult = value.As<ulong>();
+ Vector128<ulong> ulongResult = value.As<Double, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector128.Create(TestLibrary.Generator.GetDouble());
object byteResult = typeof(Vector128<Double>)
- .GetMethod(nameof(Vector128<Double>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector128.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<byte>)(byteResult), value);
value = Vector128.Create(TestLibrary.Generator.GetDouble());
object doubleResult = typeof(Vector128<Double>)
- .GetMethod(nameof(Vector128<Double>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector128.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<double>)(doubleResult), value);
value = Vector128.Create(TestLibrary.Generator.GetDouble());
object shortResult = typeof(Vector128<Double>)
- .GetMethod(nameof(Vector128<Double>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<short>)(shortResult), value);
value = Vector128.Create(TestLibrary.Generator.GetDouble());
object intResult = typeof(Vector128<Double>)
- .GetMethod(nameof(Vector128<Double>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<int>)(intResult), value);
value = Vector128.Create(TestLibrary.Generator.GetDouble());
object longResult = typeof(Vector128<Double>)
- .GetMethod(nameof(Vector128<Double>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<long>)(longResult), value);
value = Vector128.Create(TestLibrary.Generator.GetDouble());
object sbyteResult = typeof(Vector128<Double>)
- .GetMethod(nameof(Vector128<Double>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector128.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<sbyte>)(sbyteResult), value);
value = Vector128.Create(TestLibrary.Generator.GetDouble());
object floatResult = typeof(Vector128<Double>)
- .GetMethod(nameof(Vector128<Double>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector128.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<float>)(floatResult), value);
value = Vector128.Create(TestLibrary.Generator.GetDouble());
object ushortResult = typeof(Vector128<Double>)
- .GetMethod(nameof(Vector128<Double>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<ushort>)(ushortResult), value);
value = Vector128.Create(TestLibrary.Generator.GetDouble());
object uintResult = typeof(Vector128<Double>)
- .GetMethod(nameof(Vector128<Double>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<uint>)(uintResult), value);
value = Vector128.Create(TestLibrary.Generator.GetDouble());
object ulongResult = typeof(Vector128<Double>)
- .GetMethod(nameof(Vector128<Double>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<ulong>)(ulongResult), value);
}
Vector128<Int16> value;
value = Vector128.Create(TestLibrary.Generator.GetInt16());
- Vector128<byte> byteResult = value.As<byte>();
+ Vector128<byte> byteResult = value.As<Int16, byte>();
ValidateResult(byteResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt16());
- Vector128<double> doubleResult = value.As<double>();
+ Vector128<double> doubleResult = value.As<Int16, double>();
ValidateResult(doubleResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt16());
- Vector128<short> shortResult = value.As<short>();
+ Vector128<short> shortResult = value.As<Int16, short>();
ValidateResult(shortResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt16());
- Vector128<int> intResult = value.As<int>();
+ Vector128<int> intResult = value.As<Int16, int>();
ValidateResult(intResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt16());
- Vector128<long> longResult = value.As<long>();
+ Vector128<long> longResult = value.As<Int16, long>();
ValidateResult(longResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt16());
- Vector128<sbyte> sbyteResult = value.As<sbyte>();
+ Vector128<sbyte> sbyteResult = value.As<Int16, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt16());
- Vector128<float> floatResult = value.As<float>();
+ Vector128<float> floatResult = value.As<Int16, float>();
ValidateResult(floatResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt16());
- Vector128<ushort> ushortResult = value.As<ushort>();
+ Vector128<ushort> ushortResult = value.As<Int16, ushort>();
ValidateResult(ushortResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt16());
- Vector128<uint> uintResult = value.As<uint>();
+ Vector128<uint> uintResult = value.As<Int16, uint>();
ValidateResult(uintResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt16());
- Vector128<ulong> ulongResult = value.As<ulong>();
+ Vector128<ulong> ulongResult = value.As<Int16, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector128.Create(TestLibrary.Generator.GetInt16());
object byteResult = typeof(Vector128<Int16>)
- .GetMethod(nameof(Vector128<Int16>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector128.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<byte>)(byteResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt16());
object doubleResult = typeof(Vector128<Int16>)
- .GetMethod(nameof(Vector128<Int16>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector128.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<double>)(doubleResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt16());
object shortResult = typeof(Vector128<Int16>)
- .GetMethod(nameof(Vector128<Int16>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<short>)(shortResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt16());
object intResult = typeof(Vector128<Int16>)
- .GetMethod(nameof(Vector128<Int16>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<int>)(intResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt16());
object longResult = typeof(Vector128<Int16>)
- .GetMethod(nameof(Vector128<Int16>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<long>)(longResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt16());
object sbyteResult = typeof(Vector128<Int16>)
- .GetMethod(nameof(Vector128<Int16>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector128.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<sbyte>)(sbyteResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt16());
object floatResult = typeof(Vector128<Int16>)
- .GetMethod(nameof(Vector128<Int16>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector128.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<float>)(floatResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt16());
object ushortResult = typeof(Vector128<Int16>)
- .GetMethod(nameof(Vector128<Int16>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<ushort>)(ushortResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt16());
object uintResult = typeof(Vector128<Int16>)
- .GetMethod(nameof(Vector128<Int16>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<uint>)(uintResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt16());
object ulongResult = typeof(Vector128<Int16>)
- .GetMethod(nameof(Vector128<Int16>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<ulong>)(ulongResult), value);
}
Vector128<Int32> value;
value = Vector128.Create(TestLibrary.Generator.GetInt32());
- Vector128<byte> byteResult = value.As<byte>();
+ Vector128<byte> byteResult = value.As<Int32, byte>();
ValidateResult(byteResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt32());
- Vector128<double> doubleResult = value.As<double>();
+ Vector128<double> doubleResult = value.As<Int32, double>();
ValidateResult(doubleResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt32());
- Vector128<short> shortResult = value.As<short>();
+ Vector128<short> shortResult = value.As<Int32, short>();
ValidateResult(shortResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt32());
- Vector128<int> intResult = value.As<int>();
+ Vector128<int> intResult = value.As<Int32, int>();
ValidateResult(intResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt32());
- Vector128<long> longResult = value.As<long>();
+ Vector128<long> longResult = value.As<Int32, long>();
ValidateResult(longResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt32());
- Vector128<sbyte> sbyteResult = value.As<sbyte>();
+ Vector128<sbyte> sbyteResult = value.As<Int32, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt32());
- Vector128<float> floatResult = value.As<float>();
+ Vector128<float> floatResult = value.As<Int32, float>();
ValidateResult(floatResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt32());
- Vector128<ushort> ushortResult = value.As<ushort>();
+ Vector128<ushort> ushortResult = value.As<Int32, ushort>();
ValidateResult(ushortResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt32());
- Vector128<uint> uintResult = value.As<uint>();
+ Vector128<uint> uintResult = value.As<Int32, uint>();
ValidateResult(uintResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt32());
- Vector128<ulong> ulongResult = value.As<ulong>();
+ Vector128<ulong> ulongResult = value.As<Int32, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector128.Create(TestLibrary.Generator.GetInt32());
object byteResult = typeof(Vector128<Int32>)
- .GetMethod(nameof(Vector128<Int32>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector128.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<byte>)(byteResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt32());
object doubleResult = typeof(Vector128<Int32>)
- .GetMethod(nameof(Vector128<Int32>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector128.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<double>)(doubleResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt32());
object shortResult = typeof(Vector128<Int32>)
- .GetMethod(nameof(Vector128<Int32>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<short>)(shortResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt32());
object intResult = typeof(Vector128<Int32>)
- .GetMethod(nameof(Vector128<Int32>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<int>)(intResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt32());
object longResult = typeof(Vector128<Int32>)
- .GetMethod(nameof(Vector128<Int32>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<long>)(longResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt32());
object sbyteResult = typeof(Vector128<Int32>)
- .GetMethod(nameof(Vector128<Int32>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector128.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<sbyte>)(sbyteResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt32());
object floatResult = typeof(Vector128<Int32>)
- .GetMethod(nameof(Vector128<Int32>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector128.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<float>)(floatResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt32());
object ushortResult = typeof(Vector128<Int32>)
- .GetMethod(nameof(Vector128<Int32>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<ushort>)(ushortResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt32());
object uintResult = typeof(Vector128<Int32>)
- .GetMethod(nameof(Vector128<Int32>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<uint>)(uintResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt32());
object ulongResult = typeof(Vector128<Int32>)
- .GetMethod(nameof(Vector128<Int32>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<ulong>)(ulongResult), value);
}
Vector128<Int64> value;
value = Vector128.Create(TestLibrary.Generator.GetInt64());
- Vector128<byte> byteResult = value.As<byte>();
+ Vector128<byte> byteResult = value.As<Int64, byte>();
ValidateResult(byteResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt64());
- Vector128<double> doubleResult = value.As<double>();
+ Vector128<double> doubleResult = value.As<Int64, double>();
ValidateResult(doubleResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt64());
- Vector128<short> shortResult = value.As<short>();
+ Vector128<short> shortResult = value.As<Int64, short>();
ValidateResult(shortResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt64());
- Vector128<int> intResult = value.As<int>();
+ Vector128<int> intResult = value.As<Int64, int>();
ValidateResult(intResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt64());
- Vector128<long> longResult = value.As<long>();
+ Vector128<long> longResult = value.As<Int64, long>();
ValidateResult(longResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt64());
- Vector128<sbyte> sbyteResult = value.As<sbyte>();
+ Vector128<sbyte> sbyteResult = value.As<Int64, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt64());
- Vector128<float> floatResult = value.As<float>();
+ Vector128<float> floatResult = value.As<Int64, float>();
ValidateResult(floatResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt64());
- Vector128<ushort> ushortResult = value.As<ushort>();
+ Vector128<ushort> ushortResult = value.As<Int64, ushort>();
ValidateResult(ushortResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt64());
- Vector128<uint> uintResult = value.As<uint>();
+ Vector128<uint> uintResult = value.As<Int64, uint>();
ValidateResult(uintResult, value);
value = Vector128.Create(TestLibrary.Generator.GetInt64());
- Vector128<ulong> ulongResult = value.As<ulong>();
+ Vector128<ulong> ulongResult = value.As<Int64, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector128.Create(TestLibrary.Generator.GetInt64());
object byteResult = typeof(Vector128<Int64>)
- .GetMethod(nameof(Vector128<Int64>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector128.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<byte>)(byteResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt64());
object doubleResult = typeof(Vector128<Int64>)
- .GetMethod(nameof(Vector128<Int64>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector128.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<double>)(doubleResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt64());
object shortResult = typeof(Vector128<Int64>)
- .GetMethod(nameof(Vector128<Int64>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<short>)(shortResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt64());
object intResult = typeof(Vector128<Int64>)
- .GetMethod(nameof(Vector128<Int64>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<int>)(intResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt64());
object longResult = typeof(Vector128<Int64>)
- .GetMethod(nameof(Vector128<Int64>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<long>)(longResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt64());
object sbyteResult = typeof(Vector128<Int64>)
- .GetMethod(nameof(Vector128<Int64>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector128.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<sbyte>)(sbyteResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt64());
object floatResult = typeof(Vector128<Int64>)
- .GetMethod(nameof(Vector128<Int64>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector128.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<float>)(floatResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt64());
object ushortResult = typeof(Vector128<Int64>)
- .GetMethod(nameof(Vector128<Int64>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<ushort>)(ushortResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt64());
object uintResult = typeof(Vector128<Int64>)
- .GetMethod(nameof(Vector128<Int64>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<uint>)(uintResult), value);
value = Vector128.Create(TestLibrary.Generator.GetInt64());
object ulongResult = typeof(Vector128<Int64>)
- .GetMethod(nameof(Vector128<Int64>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<ulong>)(ulongResult), value);
}
Vector128<SByte> value;
value = Vector128.Create(TestLibrary.Generator.GetSByte());
- Vector128<byte> byteResult = value.As<byte>();
+ Vector128<byte> byteResult = value.As<SByte, byte>();
ValidateResult(byteResult, value);
value = Vector128.Create(TestLibrary.Generator.GetSByte());
- Vector128<double> doubleResult = value.As<double>();
+ Vector128<double> doubleResult = value.As<SByte, double>();
ValidateResult(doubleResult, value);
value = Vector128.Create(TestLibrary.Generator.GetSByte());
- Vector128<short> shortResult = value.As<short>();
+ Vector128<short> shortResult = value.As<SByte, short>();
ValidateResult(shortResult, value);
value = Vector128.Create(TestLibrary.Generator.GetSByte());
- Vector128<int> intResult = value.As<int>();
+ Vector128<int> intResult = value.As<SByte, int>();
ValidateResult(intResult, value);
value = Vector128.Create(TestLibrary.Generator.GetSByte());
- Vector128<long> longResult = value.As<long>();
+ Vector128<long> longResult = value.As<SByte, long>();
ValidateResult(longResult, value);
value = Vector128.Create(TestLibrary.Generator.GetSByte());
- Vector128<sbyte> sbyteResult = value.As<sbyte>();
+ Vector128<sbyte> sbyteResult = value.As<SByte, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector128.Create(TestLibrary.Generator.GetSByte());
- Vector128<float> floatResult = value.As<float>();
+ Vector128<float> floatResult = value.As<SByte, float>();
ValidateResult(floatResult, value);
value = Vector128.Create(TestLibrary.Generator.GetSByte());
- Vector128<ushort> ushortResult = value.As<ushort>();
+ Vector128<ushort> ushortResult = value.As<SByte, ushort>();
ValidateResult(ushortResult, value);
value = Vector128.Create(TestLibrary.Generator.GetSByte());
- Vector128<uint> uintResult = value.As<uint>();
+ Vector128<uint> uintResult = value.As<SByte, uint>();
ValidateResult(uintResult, value);
value = Vector128.Create(TestLibrary.Generator.GetSByte());
- Vector128<ulong> ulongResult = value.As<ulong>();
+ Vector128<ulong> ulongResult = value.As<SByte, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector128.Create(TestLibrary.Generator.GetSByte());
object byteResult = typeof(Vector128<SByte>)
- .GetMethod(nameof(Vector128<SByte>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector128.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<byte>)(byteResult), value);
value = Vector128.Create(TestLibrary.Generator.GetSByte());
object doubleResult = typeof(Vector128<SByte>)
- .GetMethod(nameof(Vector128<SByte>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector128.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<double>)(doubleResult), value);
value = Vector128.Create(TestLibrary.Generator.GetSByte());
object shortResult = typeof(Vector128<SByte>)
- .GetMethod(nameof(Vector128<SByte>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<short>)(shortResult), value);
value = Vector128.Create(TestLibrary.Generator.GetSByte());
object intResult = typeof(Vector128<SByte>)
- .GetMethod(nameof(Vector128<SByte>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<int>)(intResult), value);
value = Vector128.Create(TestLibrary.Generator.GetSByte());
object longResult = typeof(Vector128<SByte>)
- .GetMethod(nameof(Vector128<SByte>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<long>)(longResult), value);
value = Vector128.Create(TestLibrary.Generator.GetSByte());
object sbyteResult = typeof(Vector128<SByte>)
- .GetMethod(nameof(Vector128<SByte>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector128.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<sbyte>)(sbyteResult), value);
value = Vector128.Create(TestLibrary.Generator.GetSByte());
object floatResult = typeof(Vector128<SByte>)
- .GetMethod(nameof(Vector128<SByte>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector128.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<float>)(floatResult), value);
value = Vector128.Create(TestLibrary.Generator.GetSByte());
object ushortResult = typeof(Vector128<SByte>)
- .GetMethod(nameof(Vector128<SByte>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<ushort>)(ushortResult), value);
value = Vector128.Create(TestLibrary.Generator.GetSByte());
object uintResult = typeof(Vector128<SByte>)
- .GetMethod(nameof(Vector128<SByte>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<uint>)(uintResult), value);
value = Vector128.Create(TestLibrary.Generator.GetSByte());
object ulongResult = typeof(Vector128<SByte>)
- .GetMethod(nameof(Vector128<SByte>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<ulong>)(ulongResult), value);
}
Vector128<Single> value;
value = Vector128.Create(TestLibrary.Generator.GetSingle());
- Vector128<byte> byteResult = value.As<byte>();
+ Vector128<byte> byteResult = value.As<Single, byte>();
ValidateResult(byteResult, value);
value = Vector128.Create(TestLibrary.Generator.GetSingle());
- Vector128<double> doubleResult = value.As<double>();
+ Vector128<double> doubleResult = value.As<Single, double>();
ValidateResult(doubleResult, value);
value = Vector128.Create(TestLibrary.Generator.GetSingle());
- Vector128<short> shortResult = value.As<short>();
+ Vector128<short> shortResult = value.As<Single, short>();
ValidateResult(shortResult, value);
value = Vector128.Create(TestLibrary.Generator.GetSingle());
- Vector128<int> intResult = value.As<int>();
+ Vector128<int> intResult = value.As<Single, int>();
ValidateResult(intResult, value);
value = Vector128.Create(TestLibrary.Generator.GetSingle());
- Vector128<long> longResult = value.As<long>();
+ Vector128<long> longResult = value.As<Single, long>();
ValidateResult(longResult, value);
value = Vector128.Create(TestLibrary.Generator.GetSingle());
- Vector128<sbyte> sbyteResult = value.As<sbyte>();
+ Vector128<sbyte> sbyteResult = value.As<Single, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector128.Create(TestLibrary.Generator.GetSingle());
- Vector128<float> floatResult = value.As<float>();
+ Vector128<float> floatResult = value.As<Single, float>();
ValidateResult(floatResult, value);
value = Vector128.Create(TestLibrary.Generator.GetSingle());
- Vector128<ushort> ushortResult = value.As<ushort>();
+ Vector128<ushort> ushortResult = value.As<Single, ushort>();
ValidateResult(ushortResult, value);
value = Vector128.Create(TestLibrary.Generator.GetSingle());
- Vector128<uint> uintResult = value.As<uint>();
+ Vector128<uint> uintResult = value.As<Single, uint>();
ValidateResult(uintResult, value);
value = Vector128.Create(TestLibrary.Generator.GetSingle());
- Vector128<ulong> ulongResult = value.As<ulong>();
+ Vector128<ulong> ulongResult = value.As<Single, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector128.Create(TestLibrary.Generator.GetSingle());
object byteResult = typeof(Vector128<Single>)
- .GetMethod(nameof(Vector128<Single>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector128.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<byte>)(byteResult), value);
value = Vector128.Create(TestLibrary.Generator.GetSingle());
object doubleResult = typeof(Vector128<Single>)
- .GetMethod(nameof(Vector128<Single>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector128.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<double>)(doubleResult), value);
value = Vector128.Create(TestLibrary.Generator.GetSingle());
object shortResult = typeof(Vector128<Single>)
- .GetMethod(nameof(Vector128<Single>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<short>)(shortResult), value);
value = Vector128.Create(TestLibrary.Generator.GetSingle());
object intResult = typeof(Vector128<Single>)
- .GetMethod(nameof(Vector128<Single>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<int>)(intResult), value);
value = Vector128.Create(TestLibrary.Generator.GetSingle());
object longResult = typeof(Vector128<Single>)
- .GetMethod(nameof(Vector128<Single>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<long>)(longResult), value);
value = Vector128.Create(TestLibrary.Generator.GetSingle());
object sbyteResult = typeof(Vector128<Single>)
- .GetMethod(nameof(Vector128<Single>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector128.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<sbyte>)(sbyteResult), value);
value = Vector128.Create(TestLibrary.Generator.GetSingle());
object floatResult = typeof(Vector128<Single>)
- .GetMethod(nameof(Vector128<Single>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector128.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<float>)(floatResult), value);
value = Vector128.Create(TestLibrary.Generator.GetSingle());
object ushortResult = typeof(Vector128<Single>)
- .GetMethod(nameof(Vector128<Single>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<ushort>)(ushortResult), value);
value = Vector128.Create(TestLibrary.Generator.GetSingle());
object uintResult = typeof(Vector128<Single>)
- .GetMethod(nameof(Vector128<Single>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<uint>)(uintResult), value);
value = Vector128.Create(TestLibrary.Generator.GetSingle());
object ulongResult = typeof(Vector128<Single>)
- .GetMethod(nameof(Vector128<Single>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<ulong>)(ulongResult), value);
}
Vector128<UInt16> value;
value = Vector128.Create(TestLibrary.Generator.GetUInt16());
- Vector128<byte> byteResult = value.As<byte>();
+ Vector128<byte> byteResult = value.As<UInt16, byte>();
ValidateResult(byteResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt16());
- Vector128<double> doubleResult = value.As<double>();
+ Vector128<double> doubleResult = value.As<UInt16, double>();
ValidateResult(doubleResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt16());
- Vector128<short> shortResult = value.As<short>();
+ Vector128<short> shortResult = value.As<UInt16, short>();
ValidateResult(shortResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt16());
- Vector128<int> intResult = value.As<int>();
+ Vector128<int> intResult = value.As<UInt16, int>();
ValidateResult(intResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt16());
- Vector128<long> longResult = value.As<long>();
+ Vector128<long> longResult = value.As<UInt16, long>();
ValidateResult(longResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt16());
- Vector128<sbyte> sbyteResult = value.As<sbyte>();
+ Vector128<sbyte> sbyteResult = value.As<UInt16, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt16());
- Vector128<float> floatResult = value.As<float>();
+ Vector128<float> floatResult = value.As<UInt16, float>();
ValidateResult(floatResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt16());
- Vector128<ushort> ushortResult = value.As<ushort>();
+ Vector128<ushort> ushortResult = value.As<UInt16, ushort>();
ValidateResult(ushortResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt16());
- Vector128<uint> uintResult = value.As<uint>();
+ Vector128<uint> uintResult = value.As<UInt16, uint>();
ValidateResult(uintResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt16());
- Vector128<ulong> ulongResult = value.As<ulong>();
+ Vector128<ulong> ulongResult = value.As<UInt16, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector128.Create(TestLibrary.Generator.GetUInt16());
object byteResult = typeof(Vector128<UInt16>)
- .GetMethod(nameof(Vector128<UInt16>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector128.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<byte>)(byteResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt16());
object doubleResult = typeof(Vector128<UInt16>)
- .GetMethod(nameof(Vector128<UInt16>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector128.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<double>)(doubleResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt16());
object shortResult = typeof(Vector128<UInt16>)
- .GetMethod(nameof(Vector128<UInt16>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<short>)(shortResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt16());
object intResult = typeof(Vector128<UInt16>)
- .GetMethod(nameof(Vector128<UInt16>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<int>)(intResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt16());
object longResult = typeof(Vector128<UInt16>)
- .GetMethod(nameof(Vector128<UInt16>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<long>)(longResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt16());
object sbyteResult = typeof(Vector128<UInt16>)
- .GetMethod(nameof(Vector128<UInt16>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector128.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<sbyte>)(sbyteResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt16());
object floatResult = typeof(Vector128<UInt16>)
- .GetMethod(nameof(Vector128<UInt16>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector128.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<float>)(floatResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt16());
object ushortResult = typeof(Vector128<UInt16>)
- .GetMethod(nameof(Vector128<UInt16>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<ushort>)(ushortResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt16());
object uintResult = typeof(Vector128<UInt16>)
- .GetMethod(nameof(Vector128<UInt16>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<uint>)(uintResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt16());
object ulongResult = typeof(Vector128<UInt16>)
- .GetMethod(nameof(Vector128<UInt16>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<ulong>)(ulongResult), value);
}
Vector128<UInt32> value;
value = Vector128.Create(TestLibrary.Generator.GetUInt32());
- Vector128<byte> byteResult = value.As<byte>();
+ Vector128<byte> byteResult = value.As<UInt32, byte>();
ValidateResult(byteResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt32());
- Vector128<double> doubleResult = value.As<double>();
+ Vector128<double> doubleResult = value.As<UInt32, double>();
ValidateResult(doubleResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt32());
- Vector128<short> shortResult = value.As<short>();
+ Vector128<short> shortResult = value.As<UInt32, short>();
ValidateResult(shortResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt32());
- Vector128<int> intResult = value.As<int>();
+ Vector128<int> intResult = value.As<UInt32, int>();
ValidateResult(intResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt32());
- Vector128<long> longResult = value.As<long>();
+ Vector128<long> longResult = value.As<UInt32, long>();
ValidateResult(longResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt32());
- Vector128<sbyte> sbyteResult = value.As<sbyte>();
+ Vector128<sbyte> sbyteResult = value.As<UInt32, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt32());
- Vector128<float> floatResult = value.As<float>();
+ Vector128<float> floatResult = value.As<UInt32, float>();
ValidateResult(floatResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt32());
- Vector128<ushort> ushortResult = value.As<ushort>();
+ Vector128<ushort> ushortResult = value.As<UInt32, ushort>();
ValidateResult(ushortResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt32());
- Vector128<uint> uintResult = value.As<uint>();
+ Vector128<uint> uintResult = value.As<UInt32, uint>();
ValidateResult(uintResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt32());
- Vector128<ulong> ulongResult = value.As<ulong>();
+ Vector128<ulong> ulongResult = value.As<UInt32, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector128.Create(TestLibrary.Generator.GetUInt32());
object byteResult = typeof(Vector128<UInt32>)
- .GetMethod(nameof(Vector128<UInt32>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector128.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<byte>)(byteResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt32());
object doubleResult = typeof(Vector128<UInt32>)
- .GetMethod(nameof(Vector128<UInt32>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector128.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<double>)(doubleResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt32());
object shortResult = typeof(Vector128<UInt32>)
- .GetMethod(nameof(Vector128<UInt32>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<short>)(shortResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt32());
object intResult = typeof(Vector128<UInt32>)
- .GetMethod(nameof(Vector128<UInt32>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<int>)(intResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt32());
object longResult = typeof(Vector128<UInt32>)
- .GetMethod(nameof(Vector128<UInt32>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<long>)(longResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt32());
object sbyteResult = typeof(Vector128<UInt32>)
- .GetMethod(nameof(Vector128<UInt32>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector128.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<sbyte>)(sbyteResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt32());
object floatResult = typeof(Vector128<UInt32>)
- .GetMethod(nameof(Vector128<UInt32>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector128.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<float>)(floatResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt32());
object ushortResult = typeof(Vector128<UInt32>)
- .GetMethod(nameof(Vector128<UInt32>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<ushort>)(ushortResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt32());
object uintResult = typeof(Vector128<UInt32>)
- .GetMethod(nameof(Vector128<UInt32>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<uint>)(uintResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt32());
object ulongResult = typeof(Vector128<UInt32>)
- .GetMethod(nameof(Vector128<UInt32>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<ulong>)(ulongResult), value);
}
Vector128<UInt64> value;
value = Vector128.Create(TestLibrary.Generator.GetUInt64());
- Vector128<byte> byteResult = value.As<byte>();
+ Vector128<byte> byteResult = value.As<UInt64, byte>();
ValidateResult(byteResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt64());
- Vector128<double> doubleResult = value.As<double>();
+ Vector128<double> doubleResult = value.As<UInt64, double>();
ValidateResult(doubleResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt64());
- Vector128<short> shortResult = value.As<short>();
+ Vector128<short> shortResult = value.As<UInt64, short>();
ValidateResult(shortResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt64());
- Vector128<int> intResult = value.As<int>();
+ Vector128<int> intResult = value.As<UInt64, int>();
ValidateResult(intResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt64());
- Vector128<long> longResult = value.As<long>();
+ Vector128<long> longResult = value.As<UInt64, long>();
ValidateResult(longResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt64());
- Vector128<sbyte> sbyteResult = value.As<sbyte>();
+ Vector128<sbyte> sbyteResult = value.As<UInt64, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt64());
- Vector128<float> floatResult = value.As<float>();
+ Vector128<float> floatResult = value.As<UInt64, float>();
ValidateResult(floatResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt64());
- Vector128<ushort> ushortResult = value.As<ushort>();
+ Vector128<ushort> ushortResult = value.As<UInt64, ushort>();
ValidateResult(ushortResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt64());
- Vector128<uint> uintResult = value.As<uint>();
+ Vector128<uint> uintResult = value.As<UInt64, uint>();
ValidateResult(uintResult, value);
value = Vector128.Create(TestLibrary.Generator.GetUInt64());
- Vector128<ulong> ulongResult = value.As<ulong>();
+ Vector128<ulong> ulongResult = value.As<UInt64, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector128.Create(TestLibrary.Generator.GetUInt64());
object byteResult = typeof(Vector128<UInt64>)
- .GetMethod(nameof(Vector128<UInt64>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector128.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<byte>)(byteResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt64());
object doubleResult = typeof(Vector128<UInt64>)
- .GetMethod(nameof(Vector128<UInt64>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector128.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<double>)(doubleResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt64());
object shortResult = typeof(Vector128<UInt64>)
- .GetMethod(nameof(Vector128<UInt64>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<short>)(shortResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt64());
object intResult = typeof(Vector128<UInt64>)
- .GetMethod(nameof(Vector128<UInt64>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<int>)(intResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt64());
object longResult = typeof(Vector128<UInt64>)
- .GetMethod(nameof(Vector128<UInt64>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector128.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<long>)(longResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt64());
object sbyteResult = typeof(Vector128<UInt64>)
- .GetMethod(nameof(Vector128<UInt64>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector128.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<sbyte>)(sbyteResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt64());
object floatResult = typeof(Vector128<UInt64>)
- .GetMethod(nameof(Vector128<UInt64>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector128.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<float>)(floatResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt64());
object ushortResult = typeof(Vector128<UInt64>)
- .GetMethod(nameof(Vector128<UInt64>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<ushort>)(ushortResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt64());
object uintResult = typeof(Vector128<UInt64>)
- .GetMethod(nameof(Vector128<UInt64>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<uint>)(uintResult), value);
value = Vector128.Create(TestLibrary.Generator.GetUInt64());
object ulongResult = typeof(Vector128<UInt64>)
- .GetMethod(nameof(Vector128<UInt64>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector128.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<ulong>)(ulongResult), value);
}
try
{
object result = typeof(Vector128<Byte>)
- .GetMethod(nameof(Vector128<Byte>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Byte)(result), values);
}
try
{
object result2 = typeof(Vector128<Byte>)
- .GetMethod(nameof(Vector128<Byte>.WithElement), new Type[] { typeof(int), typeof(Byte) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(Byte) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<Byte>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<Byte>)
- .GetMethod(nameof(Vector128<Byte>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Byte)(result), values);
}
try
{
object result2 = typeof(Vector128<Byte>)
- .GetMethod(nameof(Vector128<Byte>.WithElement), new Type[] { typeof(int), typeof(Byte) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(Byte) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<Byte>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<Byte>)
- .GetMethod(nameof(Vector128<Byte>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Byte)(result), values);
}
try
{
object result2 = typeof(Vector128<Byte>)
- .GetMethod(nameof(Vector128<Byte>.WithElement), new Type[] { typeof(int), typeof(Byte) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(Byte) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<Byte>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<Double>)
- .GetMethod(nameof(Vector128<Double>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Double)(result), values);
}
try
{
object result2 = typeof(Vector128<Double>)
- .GetMethod(nameof(Vector128<Double>.WithElement), new Type[] { typeof(int), typeof(Double) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(Double) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<Double>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<Double>)
- .GetMethod(nameof(Vector128<Double>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Double)(result), values);
}
try
{
object result2 = typeof(Vector128<Double>)
- .GetMethod(nameof(Vector128<Double>.WithElement), new Type[] { typeof(int), typeof(Double) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(Double) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<Double>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<Int16>)
- .GetMethod(nameof(Vector128<Int16>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int16)(result), values);
}
try
{
object result2 = typeof(Vector128<Int16>)
- .GetMethod(nameof(Vector128<Int16>.WithElement), new Type[] { typeof(int), typeof(Int16) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(Int16) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<Int16>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<Int16>)
- .GetMethod(nameof(Vector128<Int16>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int16)(result), values);
}
try
{
object result2 = typeof(Vector128<Int16>)
- .GetMethod(nameof(Vector128<Int16>.WithElement), new Type[] { typeof(int), typeof(Int16) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(Int16) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<Int16>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<Int16>)
- .GetMethod(nameof(Vector128<Int16>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int16)(result), values);
}
try
{
object result2 = typeof(Vector128<Int16>)
- .GetMethod(nameof(Vector128<Int16>.WithElement), new Type[] { typeof(int), typeof(Int16) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(Int16) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<Int16>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<Int32>)
- .GetMethod(nameof(Vector128<Int32>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int32)(result), values);
}
try
{
object result2 = typeof(Vector128<Int32>)
- .GetMethod(nameof(Vector128<Int32>.WithElement), new Type[] { typeof(int), typeof(Int32) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(Int32) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<Int32>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<Int32>)
- .GetMethod(nameof(Vector128<Int32>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int32)(result), values);
}
try
{
object result2 = typeof(Vector128<Int32>)
- .GetMethod(nameof(Vector128<Int32>.WithElement), new Type[] { typeof(int), typeof(Int32) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(Int32) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<Int32>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<Int32>)
- .GetMethod(nameof(Vector128<Int32>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int32)(result), values);
}
try
{
object result2 = typeof(Vector128<Int32>)
- .GetMethod(nameof(Vector128<Int32>.WithElement), new Type[] { typeof(int), typeof(Int32) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(Int32) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<Int32>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<Int64>)
- .GetMethod(nameof(Vector128<Int64>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int64)(result), values);
}
try
{
object result2 = typeof(Vector128<Int64>)
- .GetMethod(nameof(Vector128<Int64>.WithElement), new Type[] { typeof(int), typeof(Int64) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(Int64) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<Int64>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<Int64>)
- .GetMethod(nameof(Vector128<Int64>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int64)(result), values);
}
try
{
object result2 = typeof(Vector128<Int64>)
- .GetMethod(nameof(Vector128<Int64>.WithElement), new Type[] { typeof(int), typeof(Int64) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(Int64) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<Int64>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<SByte>)
- .GetMethod(nameof(Vector128<SByte>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((SByte)(result), values);
}
try
{
object result2 = typeof(Vector128<SByte>)
- .GetMethod(nameof(Vector128<SByte>.WithElement), new Type[] { typeof(int), typeof(SByte) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(SByte) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<SByte>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<SByte>)
- .GetMethod(nameof(Vector128<SByte>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((SByte)(result), values);
}
try
{
object result2 = typeof(Vector128<SByte>)
- .GetMethod(nameof(Vector128<SByte>.WithElement), new Type[] { typeof(int), typeof(SByte) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(SByte) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<SByte>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<SByte>)
- .GetMethod(nameof(Vector128<SByte>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((SByte)(result), values);
}
try
{
object result2 = typeof(Vector128<SByte>)
- .GetMethod(nameof(Vector128<SByte>.WithElement), new Type[] { typeof(int), typeof(SByte) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(SByte) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<SByte>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<Single>)
- .GetMethod(nameof(Vector128<Single>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Single)(result), values);
}
try
{
object result2 = typeof(Vector128<Single>)
- .GetMethod(nameof(Vector128<Single>.WithElement), new Type[] { typeof(int), typeof(Single) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(Single) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<Single>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<Single>)
- .GetMethod(nameof(Vector128<Single>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Single)(result), values);
}
try
{
object result2 = typeof(Vector128<Single>)
- .GetMethod(nameof(Vector128<Single>.WithElement), new Type[] { typeof(int), typeof(Single) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(Single) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<Single>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<Single>)
- .GetMethod(nameof(Vector128<Single>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Single)(result), values);
}
try
{
object result2 = typeof(Vector128<Single>)
- .GetMethod(nameof(Vector128<Single>.WithElement), new Type[] { typeof(int), typeof(Single) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(Single) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<Single>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<UInt16>)
- .GetMethod(nameof(Vector128<UInt16>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt16)(result), values);
}
try
{
object result2 = typeof(Vector128<UInt16>)
- .GetMethod(nameof(Vector128<UInt16>.WithElement), new Type[] { typeof(int), typeof(UInt16) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(UInt16) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<UInt16>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<UInt16>)
- .GetMethod(nameof(Vector128<UInt16>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt16)(result), values);
}
try
{
object result2 = typeof(Vector128<UInt16>)
- .GetMethod(nameof(Vector128<UInt16>.WithElement), new Type[] { typeof(int), typeof(UInt16) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(UInt16) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<UInt16>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<UInt16>)
- .GetMethod(nameof(Vector128<UInt16>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt16)(result), values);
}
try
{
object result2 = typeof(Vector128<UInt16>)
- .GetMethod(nameof(Vector128<UInt16>.WithElement), new Type[] { typeof(int), typeof(UInt16) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(UInt16) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<UInt16>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<UInt32>)
- .GetMethod(nameof(Vector128<UInt32>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt32)(result), values);
}
try
{
object result2 = typeof(Vector128<UInt32>)
- .GetMethod(nameof(Vector128<UInt32>.WithElement), new Type[] { typeof(int), typeof(UInt32) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(UInt32) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<UInt32>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<UInt32>)
- .GetMethod(nameof(Vector128<UInt32>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt32)(result), values);
}
try
{
object result2 = typeof(Vector128<UInt32>)
- .GetMethod(nameof(Vector128<UInt32>.WithElement), new Type[] { typeof(int), typeof(UInt32) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(UInt32) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<UInt32>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<UInt32>)
- .GetMethod(nameof(Vector128<UInt32>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt32)(result), values);
}
try
{
object result2 = typeof(Vector128<UInt32>)
- .GetMethod(nameof(Vector128<UInt32>.WithElement), new Type[] { typeof(int), typeof(UInt32) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(UInt32) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<UInt32>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<UInt64>)
- .GetMethod(nameof(Vector128<UInt64>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt64)(result), values);
}
try
{
object result2 = typeof(Vector128<UInt64>)
- .GetMethod(nameof(Vector128<UInt64>.WithElement), new Type[] { typeof(int), typeof(UInt64) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(UInt64) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<UInt64>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector128<UInt64>)
- .GetMethod(nameof(Vector128<UInt64>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector128.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt64)(result), values);
}
try
{
object result2 = typeof(Vector128<UInt64>)
- .GetMethod(nameof(Vector128<UInt64>.WithElement), new Type[] { typeof(int), typeof(UInt64) })
+ .GetMethod(nameof(Vector128.WithElement), new Type[] { typeof(int), typeof(UInt64) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector128<UInt64>)(result2), values, insertedValue);
}
Vector128<Byte> value = Vector128.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]);
object lowerResult = typeof(Vector128<Byte>)
- .GetMethod(nameof(Vector128<Byte>.GetLower), new Type[] { })
+ .GetMethod(nameof(Vector128.GetLower), new Type[] { })
.Invoke(value, new object[] { });
object upperResult = typeof(Vector128<Byte>)
- .GetMethod(nameof(Vector128<Byte>.GetUpper), new Type[] { })
+ .GetMethod(nameof(Vector128.GetUpper), new Type[] { })
.Invoke(value, new object[] { });
ValidateGetResult((Vector64<Byte>)(lowerResult), (Vector64<Byte>)(upperResult), values);
object result = typeof(Vector128<Byte>)
- .GetMethod(nameof(Vector128<Byte>.WithLower), new Type[] { typeof(Vector64<Byte>) })
+ .GetMethod(nameof(Vector128.WithLower), new Type[] { typeof(Vector64<Byte>) })
.Invoke(value, new object[] { upperResult });
result = typeof(Vector128<Byte>)
- .GetMethod(nameof(Vector128<Byte>.WithUpper), new Type[] { typeof(Vector64<Byte>) })
+ .GetMethod(nameof(Vector128.WithUpper), new Type[] { typeof(Vector64<Byte>) })
.Invoke(result, new object[] { lowerResult });
ValidateWithResult((Vector128<Byte>)(result), values);
}
Vector128<Double> value = Vector128.Create(values[0], values[1]);
object lowerResult = typeof(Vector128<Double>)
- .GetMethod(nameof(Vector128<Double>.GetLower), new Type[] { })
+ .GetMethod(nameof(Vector128.GetLower), new Type[] { })
.Invoke(value, new object[] { });
object upperResult = typeof(Vector128<Double>)
- .GetMethod(nameof(Vector128<Double>.GetUpper), new Type[] { })
+ .GetMethod(nameof(Vector128.GetUpper), new Type[] { })
.Invoke(value, new object[] { });
ValidateGetResult((Vector64<Double>)(lowerResult), (Vector64<Double>)(upperResult), values);
object result = typeof(Vector128<Double>)
- .GetMethod(nameof(Vector128<Double>.WithLower), new Type[] { typeof(Vector64<Double>) })
+ .GetMethod(nameof(Vector128.WithLower), new Type[] { typeof(Vector64<Double>) })
.Invoke(value, new object[] { upperResult });
result = typeof(Vector128<Double>)
- .GetMethod(nameof(Vector128<Double>.WithUpper), new Type[] { typeof(Vector64<Double>) })
+ .GetMethod(nameof(Vector128.WithUpper), new Type[] { typeof(Vector64<Double>) })
.Invoke(result, new object[] { lowerResult });
ValidateWithResult((Vector128<Double>)(result), values);
}
Vector128<Int16> value = Vector128.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]);
object lowerResult = typeof(Vector128<Int16>)
- .GetMethod(nameof(Vector128<Int16>.GetLower), new Type[] { })
+ .GetMethod(nameof(Vector128.GetLower), new Type[] { })
.Invoke(value, new object[] { });
object upperResult = typeof(Vector128<Int16>)
- .GetMethod(nameof(Vector128<Int16>.GetUpper), new Type[] { })
+ .GetMethod(nameof(Vector128.GetUpper), new Type[] { })
.Invoke(value, new object[] { });
ValidateGetResult((Vector64<Int16>)(lowerResult), (Vector64<Int16>)(upperResult), values);
object result = typeof(Vector128<Int16>)
- .GetMethod(nameof(Vector128<Int16>.WithLower), new Type[] { typeof(Vector64<Int16>) })
+ .GetMethod(nameof(Vector128.WithLower), new Type[] { typeof(Vector64<Int16>) })
.Invoke(value, new object[] { upperResult });
result = typeof(Vector128<Int16>)
- .GetMethod(nameof(Vector128<Int16>.WithUpper), new Type[] { typeof(Vector64<Int16>) })
+ .GetMethod(nameof(Vector128.WithUpper), new Type[] { typeof(Vector64<Int16>) })
.Invoke(result, new object[] { lowerResult });
ValidateWithResult((Vector128<Int16>)(result), values);
}
Vector128<Int32> value = Vector128.Create(values[0], values[1], values[2], values[3]);
object lowerResult = typeof(Vector128<Int32>)
- .GetMethod(nameof(Vector128<Int32>.GetLower), new Type[] { })
+ .GetMethod(nameof(Vector128.GetLower), new Type[] { })
.Invoke(value, new object[] { });
object upperResult = typeof(Vector128<Int32>)
- .GetMethod(nameof(Vector128<Int32>.GetUpper), new Type[] { })
+ .GetMethod(nameof(Vector128.GetUpper), new Type[] { })
.Invoke(value, new object[] { });
ValidateGetResult((Vector64<Int32>)(lowerResult), (Vector64<Int32>)(upperResult), values);
object result = typeof(Vector128<Int32>)
- .GetMethod(nameof(Vector128<Int32>.WithLower), new Type[] { typeof(Vector64<Int32>) })
+ .GetMethod(nameof(Vector128.WithLower), new Type[] { typeof(Vector64<Int32>) })
.Invoke(value, new object[] { upperResult });
result = typeof(Vector128<Int32>)
- .GetMethod(nameof(Vector128<Int32>.WithUpper), new Type[] { typeof(Vector64<Int32>) })
+ .GetMethod(nameof(Vector128.WithUpper), new Type[] { typeof(Vector64<Int32>) })
.Invoke(result, new object[] { lowerResult });
ValidateWithResult((Vector128<Int32>)(result), values);
}
Vector128<Int64> value = Vector128.Create(values[0], values[1]);
object lowerResult = typeof(Vector128<Int64>)
- .GetMethod(nameof(Vector128<Int64>.GetLower), new Type[] { })
+ .GetMethod(nameof(Vector128.GetLower), new Type[] { })
.Invoke(value, new object[] { });
object upperResult = typeof(Vector128<Int64>)
- .GetMethod(nameof(Vector128<Int64>.GetUpper), new Type[] { })
+ .GetMethod(nameof(Vector128.GetUpper), new Type[] { })
.Invoke(value, new object[] { });
ValidateGetResult((Vector64<Int64>)(lowerResult), (Vector64<Int64>)(upperResult), values);
object result = typeof(Vector128<Int64>)
- .GetMethod(nameof(Vector128<Int64>.WithLower), new Type[] { typeof(Vector64<Int64>) })
+ .GetMethod(nameof(Vector128.WithLower), new Type[] { typeof(Vector64<Int64>) })
.Invoke(value, new object[] { upperResult });
result = typeof(Vector128<Int64>)
- .GetMethod(nameof(Vector128<Int64>.WithUpper), new Type[] { typeof(Vector64<Int64>) })
+ .GetMethod(nameof(Vector128.WithUpper), new Type[] { typeof(Vector64<Int64>) })
.Invoke(result, new object[] { lowerResult });
ValidateWithResult((Vector128<Int64>)(result), values);
}
Vector128<SByte> value = Vector128.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]);
object lowerResult = typeof(Vector128<SByte>)
- .GetMethod(nameof(Vector128<SByte>.GetLower), new Type[] { })
+ .GetMethod(nameof(Vector128.GetLower), new Type[] { })
.Invoke(value, new object[] { });
object upperResult = typeof(Vector128<SByte>)
- .GetMethod(nameof(Vector128<SByte>.GetUpper), new Type[] { })
+ .GetMethod(nameof(Vector128.GetUpper), new Type[] { })
.Invoke(value, new object[] { });
ValidateGetResult((Vector64<SByte>)(lowerResult), (Vector64<SByte>)(upperResult), values);
object result = typeof(Vector128<SByte>)
- .GetMethod(nameof(Vector128<SByte>.WithLower), new Type[] { typeof(Vector64<SByte>) })
+ .GetMethod(nameof(Vector128.WithLower), new Type[] { typeof(Vector64<SByte>) })
.Invoke(value, new object[] { upperResult });
result = typeof(Vector128<SByte>)
- .GetMethod(nameof(Vector128<SByte>.WithUpper), new Type[] { typeof(Vector64<SByte>) })
+ .GetMethod(nameof(Vector128.WithUpper), new Type[] { typeof(Vector64<SByte>) })
.Invoke(result, new object[] { lowerResult });
ValidateWithResult((Vector128<SByte>)(result), values);
}
Vector128<Single> value = Vector128.Create(values[0], values[1], values[2], values[3]);
object lowerResult = typeof(Vector128<Single>)
- .GetMethod(nameof(Vector128<Single>.GetLower), new Type[] { })
+ .GetMethod(nameof(Vector128.GetLower), new Type[] { })
.Invoke(value, new object[] { });
object upperResult = typeof(Vector128<Single>)
- .GetMethod(nameof(Vector128<Single>.GetUpper), new Type[] { })
+ .GetMethod(nameof(Vector128.GetUpper), new Type[] { })
.Invoke(value, new object[] { });
ValidateGetResult((Vector64<Single>)(lowerResult), (Vector64<Single>)(upperResult), values);
object result = typeof(Vector128<Single>)
- .GetMethod(nameof(Vector128<Single>.WithLower), new Type[] { typeof(Vector64<Single>) })
+ .GetMethod(nameof(Vector128.WithLower), new Type[] { typeof(Vector64<Single>) })
.Invoke(value, new object[] { upperResult });
result = typeof(Vector128<Single>)
- .GetMethod(nameof(Vector128<Single>.WithUpper), new Type[] { typeof(Vector64<Single>) })
+ .GetMethod(nameof(Vector128.WithUpper), new Type[] { typeof(Vector64<Single>) })
.Invoke(result, new object[] { lowerResult });
ValidateWithResult((Vector128<Single>)(result), values);
}
Vector128<UInt16> value = Vector128.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]);
object lowerResult = typeof(Vector128<UInt16>)
- .GetMethod(nameof(Vector128<UInt16>.GetLower), new Type[] { })
+ .GetMethod(nameof(Vector128.GetLower), new Type[] { })
.Invoke(value, new object[] { });
object upperResult = typeof(Vector128<UInt16>)
- .GetMethod(nameof(Vector128<UInt16>.GetUpper), new Type[] { })
+ .GetMethod(nameof(Vector128.GetUpper), new Type[] { })
.Invoke(value, new object[] { });
ValidateGetResult((Vector64<UInt16>)(lowerResult), (Vector64<UInt16>)(upperResult), values);
object result = typeof(Vector128<UInt16>)
- .GetMethod(nameof(Vector128<UInt16>.WithLower), new Type[] { typeof(Vector64<UInt16>) })
+ .GetMethod(nameof(Vector128.WithLower), new Type[] { typeof(Vector64<UInt16>) })
.Invoke(value, new object[] { upperResult });
result = typeof(Vector128<UInt16>)
- .GetMethod(nameof(Vector128<UInt16>.WithUpper), new Type[] { typeof(Vector64<UInt16>) })
+ .GetMethod(nameof(Vector128.WithUpper), new Type[] { typeof(Vector64<UInt16>) })
.Invoke(result, new object[] { lowerResult });
ValidateWithResult((Vector128<UInt16>)(result), values);
}
Vector128<UInt32> value = Vector128.Create(values[0], values[1], values[2], values[3]);
object lowerResult = typeof(Vector128<UInt32>)
- .GetMethod(nameof(Vector128<UInt32>.GetLower), new Type[] { })
+ .GetMethod(nameof(Vector128.GetLower), new Type[] { })
.Invoke(value, new object[] { });
object upperResult = typeof(Vector128<UInt32>)
- .GetMethod(nameof(Vector128<UInt32>.GetUpper), new Type[] { })
+ .GetMethod(nameof(Vector128.GetUpper), new Type[] { })
.Invoke(value, new object[] { });
ValidateGetResult((Vector64<UInt32>)(lowerResult), (Vector64<UInt32>)(upperResult), values);
object result = typeof(Vector128<UInt32>)
- .GetMethod(nameof(Vector128<UInt32>.WithLower), new Type[] { typeof(Vector64<UInt32>) })
+ .GetMethod(nameof(Vector128.WithLower), new Type[] { typeof(Vector64<UInt32>) })
.Invoke(value, new object[] { upperResult });
result = typeof(Vector128<UInt32>)
- .GetMethod(nameof(Vector128<UInt32>.WithUpper), new Type[] { typeof(Vector64<UInt32>) })
+ .GetMethod(nameof(Vector128.WithUpper), new Type[] { typeof(Vector64<UInt32>) })
.Invoke(result, new object[] { lowerResult });
ValidateWithResult((Vector128<UInt32>)(result), values);
}
Vector128<UInt64> value = Vector128.Create(values[0], values[1]);
object lowerResult = typeof(Vector128<UInt64>)
- .GetMethod(nameof(Vector128<UInt64>.GetLower), new Type[] { })
+ .GetMethod(nameof(Vector128.GetLower), new Type[] { })
.Invoke(value, new object[] { });
object upperResult = typeof(Vector128<UInt64>)
- .GetMethod(nameof(Vector128<UInt64>.GetUpper), new Type[] { })
+ .GetMethod(nameof(Vector128.GetUpper), new Type[] { })
.Invoke(value, new object[] { });
ValidateGetResult((Vector64<UInt64>)(lowerResult), (Vector64<UInt64>)(upperResult), values);
object result = typeof(Vector128<UInt64>)
- .GetMethod(nameof(Vector128<UInt64>.WithLower), new Type[] { typeof(Vector64<UInt64>) })
+ .GetMethod(nameof(Vector128.WithLower), new Type[] { typeof(Vector64<UInt64>) })
.Invoke(value, new object[] { upperResult });
result = typeof(Vector128<UInt64>)
- .GetMethod(nameof(Vector128<UInt64>.WithUpper), new Type[] { typeof(Vector64<UInt64>) })
+ .GetMethod(nameof(Vector128.WithUpper), new Type[] { typeof(Vector64<UInt64>) })
.Invoke(result, new object[] { lowerResult });
ValidateWithResult((Vector128<UInt64>)(result), values);
}
Vector128<Byte> value = Vector128.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]);
object result = typeof(Vector128<Byte>)
- .GetMethod(nameof(Vector128<Byte>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector128.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Byte)(result), values);
Vector128<Double> value = Vector128.Create(values[0], values[1]);
object result = typeof(Vector128<Double>)
- .GetMethod(nameof(Vector128<Double>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector128.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Double)(result), values);
Vector128<Int16> value = Vector128.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]);
object result = typeof(Vector128<Int16>)
- .GetMethod(nameof(Vector128<Int16>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector128.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Int16)(result), values);
Vector128<Int32> value = Vector128.Create(values[0], values[1], values[2], values[3]);
object result = typeof(Vector128<Int32>)
- .GetMethod(nameof(Vector128<Int32>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector128.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Int32)(result), values);
Vector128<Int64> value = Vector128.Create(values[0], values[1]);
object result = typeof(Vector128<Int64>)
- .GetMethod(nameof(Vector128<Int64>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector128.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Int64)(result), values);
Vector128<SByte> value = Vector128.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]);
object result = typeof(Vector128<SByte>)
- .GetMethod(nameof(Vector128<SByte>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector128.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((SByte)(result), values);
Vector128<Single> value = Vector128.Create(values[0], values[1], values[2], values[3]);
object result = typeof(Vector128<Single>)
- .GetMethod(nameof(Vector128<Single>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector128.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Single)(result), values);
Vector128<UInt16> value = Vector128.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]);
object result = typeof(Vector128<UInt16>)
- .GetMethod(nameof(Vector128<UInt16>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector128.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((UInt16)(result), values);
Vector128<UInt32> value = Vector128.Create(values[0], values[1], values[2], values[3]);
object result = typeof(Vector128<UInt32>)
- .GetMethod(nameof(Vector128<UInt32>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector128.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((UInt32)(result), values);
Vector128<UInt64> value = Vector128.Create(values[0], values[1]);
object result = typeof(Vector128<UInt64>)
- .GetMethod(nameof(Vector128<UInt64>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector128.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((UInt64)(result), values);
Vector128<Byte> value = Vector128.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]);
object result = typeof(Vector128<Byte>)
- .GetMethod(nameof(Vector128<Byte>.ToVector256), new Type[] { })
+ .GetMethod(nameof(Vector128.ToVector256), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<Byte>)(result), values, isUnsafe: false);
object unsafeResult = typeof(Vector128<Byte>)
- .GetMethod(nameof(Vector128<Byte>.ToVector256), new Type[] { })
+ .GetMethod(nameof(Vector128.ToVector256), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<Byte>)(unsafeResult), values, isUnsafe: true);
}
Vector128<Double> value = Vector128.Create(values[0], values[1]);
object result = typeof(Vector128<Double>)
- .GetMethod(nameof(Vector128<Double>.ToVector256), new Type[] { })
+ .GetMethod(nameof(Vector128.ToVector256), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<Double>)(result), values, isUnsafe: false);
object unsafeResult = typeof(Vector128<Double>)
- .GetMethod(nameof(Vector128<Double>.ToVector256), new Type[] { })
+ .GetMethod(nameof(Vector128.ToVector256), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<Double>)(unsafeResult), values, isUnsafe: true);
}
Vector128<Int16> value = Vector128.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]);
object result = typeof(Vector128<Int16>)
- .GetMethod(nameof(Vector128<Int16>.ToVector256), new Type[] { })
+ .GetMethod(nameof(Vector128.ToVector256), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<Int16>)(result), values, isUnsafe: false);
object unsafeResult = typeof(Vector128<Int16>)
- .GetMethod(nameof(Vector128<Int16>.ToVector256), new Type[] { })
+ .GetMethod(nameof(Vector128.ToVector256), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<Int16>)(unsafeResult), values, isUnsafe: true);
}
Vector128<Int32> value = Vector128.Create(values[0], values[1], values[2], values[3]);
object result = typeof(Vector128<Int32>)
- .GetMethod(nameof(Vector128<Int32>.ToVector256), new Type[] { })
+ .GetMethod(nameof(Vector128.ToVector256), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<Int32>)(result), values, isUnsafe: false);
object unsafeResult = typeof(Vector128<Int32>)
- .GetMethod(nameof(Vector128<Int32>.ToVector256), new Type[] { })
+ .GetMethod(nameof(Vector128.ToVector256), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<Int32>)(unsafeResult), values, isUnsafe: true);
}
Vector128<Int64> value = Vector128.Create(values[0], values[1]);
object result = typeof(Vector128<Int64>)
- .GetMethod(nameof(Vector128<Int64>.ToVector256), new Type[] { })
+ .GetMethod(nameof(Vector128.ToVector256), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<Int64>)(result), values, isUnsafe: false);
object unsafeResult = typeof(Vector128<Int64>)
- .GetMethod(nameof(Vector128<Int64>.ToVector256), new Type[] { })
+ .GetMethod(nameof(Vector128.ToVector256), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<Int64>)(unsafeResult), values, isUnsafe: true);
}
Vector128<SByte> value = Vector128.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]);
object result = typeof(Vector128<SByte>)
- .GetMethod(nameof(Vector128<SByte>.ToVector256), new Type[] { })
+ .GetMethod(nameof(Vector128.ToVector256), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<SByte>)(result), values, isUnsafe: false);
object unsafeResult = typeof(Vector128<SByte>)
- .GetMethod(nameof(Vector128<SByte>.ToVector256), new Type[] { })
+ .GetMethod(nameof(Vector128.ToVector256), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<SByte>)(unsafeResult), values, isUnsafe: true);
}
Vector128<Single> value = Vector128.Create(values[0], values[1], values[2], values[3]);
object result = typeof(Vector128<Single>)
- .GetMethod(nameof(Vector128<Single>.ToVector256), new Type[] { })
+ .GetMethod(nameof(Vector128.ToVector256), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<Single>)(result), values, isUnsafe: false);
object unsafeResult = typeof(Vector128<Single>)
- .GetMethod(nameof(Vector128<Single>.ToVector256), new Type[] { })
+ .GetMethod(nameof(Vector128.ToVector256), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<Single>)(unsafeResult), values, isUnsafe: true);
}
Vector128<UInt16> value = Vector128.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]);
object result = typeof(Vector128<UInt16>)
- .GetMethod(nameof(Vector128<UInt16>.ToVector256), new Type[] { })
+ .GetMethod(nameof(Vector128.ToVector256), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<UInt16>)(result), values, isUnsafe: false);
object unsafeResult = typeof(Vector128<UInt16>)
- .GetMethod(nameof(Vector128<UInt16>.ToVector256), new Type[] { })
+ .GetMethod(nameof(Vector128.ToVector256), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<UInt16>)(unsafeResult), values, isUnsafe: true);
}
Vector128<UInt32> value = Vector128.Create(values[0], values[1], values[2], values[3]);
object result = typeof(Vector128<UInt32>)
- .GetMethod(nameof(Vector128<UInt32>.ToVector256), new Type[] { })
+ .GetMethod(nameof(Vector128.ToVector256), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<UInt32>)(result), values, isUnsafe: false);
object unsafeResult = typeof(Vector128<UInt32>)
- .GetMethod(nameof(Vector128<UInt32>.ToVector256), new Type[] { })
+ .GetMethod(nameof(Vector128.ToVector256), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<UInt32>)(unsafeResult), values, isUnsafe: true);
}
Vector128<UInt64> value = Vector128.Create(values[0], values[1]);
object result = typeof(Vector128<UInt64>)
- .GetMethod(nameof(Vector128<UInt64>.ToVector256), new Type[] { })
+ .GetMethod(nameof(Vector128.ToVector256), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<UInt64>)(result), values, isUnsafe: false);
object unsafeResult = typeof(Vector128<UInt64>)
- .GetMethod(nameof(Vector128<UInt64>.ToVector256), new Type[] { })
+ .GetMethod(nameof(Vector128.ToVector256), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<UInt64>)(unsafeResult), values, isUnsafe: true);
}
Vector256<Byte> value;
value = Vector256.Create(TestLibrary.Generator.GetByte());
- Vector256<byte> byteResult = value.As<byte>();
+ Vector256<byte> byteResult = value.As<Byte, byte>();
ValidateResult(byteResult, value);
value = Vector256.Create(TestLibrary.Generator.GetByte());
- Vector256<double> doubleResult = value.As<double>();
+ Vector256<double> doubleResult = value.As<Byte, double>();
ValidateResult(doubleResult, value);
value = Vector256.Create(TestLibrary.Generator.GetByte());
- Vector256<short> shortResult = value.As<short>();
+ Vector256<short> shortResult = value.As<Byte, short>();
ValidateResult(shortResult, value);
value = Vector256.Create(TestLibrary.Generator.GetByte());
- Vector256<int> intResult = value.As<int>();
+ Vector256<int> intResult = value.As<Byte, int>();
ValidateResult(intResult, value);
value = Vector256.Create(TestLibrary.Generator.GetByte());
- Vector256<long> longResult = value.As<long>();
+ Vector256<long> longResult = value.As<Byte, long>();
ValidateResult(longResult, value);
value = Vector256.Create(TestLibrary.Generator.GetByte());
- Vector256<sbyte> sbyteResult = value.As<sbyte>();
+ Vector256<sbyte> sbyteResult = value.As<Byte, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector256.Create(TestLibrary.Generator.GetByte());
- Vector256<float> floatResult = value.As<float>();
+ Vector256<float> floatResult = value.As<Byte, float>();
ValidateResult(floatResult, value);
value = Vector256.Create(TestLibrary.Generator.GetByte());
- Vector256<ushort> ushortResult = value.As<ushort>();
+ Vector256<ushort> ushortResult = value.As<Byte, ushort>();
ValidateResult(ushortResult, value);
value = Vector256.Create(TestLibrary.Generator.GetByte());
- Vector256<uint> uintResult = value.As<uint>();
+ Vector256<uint> uintResult = value.As<Byte, uint>();
ValidateResult(uintResult, value);
value = Vector256.Create(TestLibrary.Generator.GetByte());
- Vector256<ulong> ulongResult = value.As<ulong>();
+ Vector256<ulong> ulongResult = value.As<Byte, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector256.Create(TestLibrary.Generator.GetByte());
object byteResult = typeof(Vector256<Byte>)
- .GetMethod(nameof(Vector256<Byte>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector256.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<byte>)(byteResult), value);
value = Vector256.Create(TestLibrary.Generator.GetByte());
object doubleResult = typeof(Vector256<Byte>)
- .GetMethod(nameof(Vector256<Byte>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector256.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<double>)(doubleResult), value);
value = Vector256.Create(TestLibrary.Generator.GetByte());
object shortResult = typeof(Vector256<Byte>)
- .GetMethod(nameof(Vector256<Byte>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<short>)(shortResult), value);
value = Vector256.Create(TestLibrary.Generator.GetByte());
object intResult = typeof(Vector256<Byte>)
- .GetMethod(nameof(Vector256<Byte>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<int>)(intResult), value);
value = Vector256.Create(TestLibrary.Generator.GetByte());
object longResult = typeof(Vector256<Byte>)
- .GetMethod(nameof(Vector256<Byte>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<long>)(longResult), value);
value = Vector256.Create(TestLibrary.Generator.GetByte());
object sbyteResult = typeof(Vector256<Byte>)
- .GetMethod(nameof(Vector256<Byte>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector256.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<sbyte>)(sbyteResult), value);
value = Vector256.Create(TestLibrary.Generator.GetByte());
object floatResult = typeof(Vector256<Byte>)
- .GetMethod(nameof(Vector256<Byte>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector256.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<float>)(floatResult), value);
value = Vector256.Create(TestLibrary.Generator.GetByte());
object ushortResult = typeof(Vector256<Byte>)
- .GetMethod(nameof(Vector256<Byte>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<ushort>)(ushortResult), value);
value = Vector256.Create(TestLibrary.Generator.GetByte());
object uintResult = typeof(Vector256<Byte>)
- .GetMethod(nameof(Vector256<Byte>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<uint>)(uintResult), value);
value = Vector256.Create(TestLibrary.Generator.GetByte());
object ulongResult = typeof(Vector256<Byte>)
- .GetMethod(nameof(Vector256<Byte>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<ulong>)(ulongResult), value);
}
Vector256<Double> value;
value = Vector256.Create(TestLibrary.Generator.GetDouble());
- Vector256<byte> byteResult = value.As<byte>();
+ Vector256<byte> byteResult = value.As<Double, byte>();
ValidateResult(byteResult, value);
value = Vector256.Create(TestLibrary.Generator.GetDouble());
- Vector256<double> doubleResult = value.As<double>();
+ Vector256<double> doubleResult = value.As<Double, double>();
ValidateResult(doubleResult, value);
value = Vector256.Create(TestLibrary.Generator.GetDouble());
- Vector256<short> shortResult = value.As<short>();
+ Vector256<short> shortResult = value.As<Double, short>();
ValidateResult(shortResult, value);
value = Vector256.Create(TestLibrary.Generator.GetDouble());
- Vector256<int> intResult = value.As<int>();
+ Vector256<int> intResult = value.As<Double, int>();
ValidateResult(intResult, value);
value = Vector256.Create(TestLibrary.Generator.GetDouble());
- Vector256<long> longResult = value.As<long>();
+ Vector256<long> longResult = value.As<Double, long>();
ValidateResult(longResult, value);
value = Vector256.Create(TestLibrary.Generator.GetDouble());
- Vector256<sbyte> sbyteResult = value.As<sbyte>();
+ Vector256<sbyte> sbyteResult = value.As<Double, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector256.Create(TestLibrary.Generator.GetDouble());
- Vector256<float> floatResult = value.As<float>();
+ Vector256<float> floatResult = value.As<Double, float>();
ValidateResult(floatResult, value);
value = Vector256.Create(TestLibrary.Generator.GetDouble());
- Vector256<ushort> ushortResult = value.As<ushort>();
+ Vector256<ushort> ushortResult = value.As<Double, ushort>();
ValidateResult(ushortResult, value);
value = Vector256.Create(TestLibrary.Generator.GetDouble());
- Vector256<uint> uintResult = value.As<uint>();
+ Vector256<uint> uintResult = value.As<Double, uint>();
ValidateResult(uintResult, value);
value = Vector256.Create(TestLibrary.Generator.GetDouble());
- Vector256<ulong> ulongResult = value.As<ulong>();
+ Vector256<ulong> ulongResult = value.As<Double, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector256.Create(TestLibrary.Generator.GetDouble());
object byteResult = typeof(Vector256<Double>)
- .GetMethod(nameof(Vector256<Double>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector256.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<byte>)(byteResult), value);
value = Vector256.Create(TestLibrary.Generator.GetDouble());
object doubleResult = typeof(Vector256<Double>)
- .GetMethod(nameof(Vector256<Double>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector256.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<double>)(doubleResult), value);
value = Vector256.Create(TestLibrary.Generator.GetDouble());
object shortResult = typeof(Vector256<Double>)
- .GetMethod(nameof(Vector256<Double>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<short>)(shortResult), value);
value = Vector256.Create(TestLibrary.Generator.GetDouble());
object intResult = typeof(Vector256<Double>)
- .GetMethod(nameof(Vector256<Double>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<int>)(intResult), value);
value = Vector256.Create(TestLibrary.Generator.GetDouble());
object longResult = typeof(Vector256<Double>)
- .GetMethod(nameof(Vector256<Double>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<long>)(longResult), value);
value = Vector256.Create(TestLibrary.Generator.GetDouble());
object sbyteResult = typeof(Vector256<Double>)
- .GetMethod(nameof(Vector256<Double>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector256.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<sbyte>)(sbyteResult), value);
value = Vector256.Create(TestLibrary.Generator.GetDouble());
object floatResult = typeof(Vector256<Double>)
- .GetMethod(nameof(Vector256<Double>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector256.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<float>)(floatResult), value);
value = Vector256.Create(TestLibrary.Generator.GetDouble());
object ushortResult = typeof(Vector256<Double>)
- .GetMethod(nameof(Vector256<Double>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<ushort>)(ushortResult), value);
value = Vector256.Create(TestLibrary.Generator.GetDouble());
object uintResult = typeof(Vector256<Double>)
- .GetMethod(nameof(Vector256<Double>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<uint>)(uintResult), value);
value = Vector256.Create(TestLibrary.Generator.GetDouble());
object ulongResult = typeof(Vector256<Double>)
- .GetMethod(nameof(Vector256<Double>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<ulong>)(ulongResult), value);
}
Vector256<Int16> value;
value = Vector256.Create(TestLibrary.Generator.GetInt16());
- Vector256<byte> byteResult = value.As<byte>();
+ Vector256<byte> byteResult = value.As<Int16, byte>();
ValidateResult(byteResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt16());
- Vector256<double> doubleResult = value.As<double>();
+ Vector256<double> doubleResult = value.As<Int16, double>();
ValidateResult(doubleResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt16());
- Vector256<short> shortResult = value.As<short>();
+ Vector256<short> shortResult = value.As<Int16, short>();
ValidateResult(shortResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt16());
- Vector256<int> intResult = value.As<int>();
+ Vector256<int> intResult = value.As<Int16, int>();
ValidateResult(intResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt16());
- Vector256<long> longResult = value.As<long>();
+ Vector256<long> longResult = value.As<Int16, long>();
ValidateResult(longResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt16());
- Vector256<sbyte> sbyteResult = value.As<sbyte>();
+ Vector256<sbyte> sbyteResult = value.As<Int16, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt16());
- Vector256<float> floatResult = value.As<float>();
+ Vector256<float> floatResult = value.As<Int16, float>();
ValidateResult(floatResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt16());
- Vector256<ushort> ushortResult = value.As<ushort>();
+ Vector256<ushort> ushortResult = value.As<Int16, ushort>();
ValidateResult(ushortResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt16());
- Vector256<uint> uintResult = value.As<uint>();
+ Vector256<uint> uintResult = value.As<Int16, uint>();
ValidateResult(uintResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt16());
- Vector256<ulong> ulongResult = value.As<ulong>();
+ Vector256<ulong> ulongResult = value.As<Int16, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector256.Create(TestLibrary.Generator.GetInt16());
object byteResult = typeof(Vector256<Int16>)
- .GetMethod(nameof(Vector256<Int16>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector256.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<byte>)(byteResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt16());
object doubleResult = typeof(Vector256<Int16>)
- .GetMethod(nameof(Vector256<Int16>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector256.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<double>)(doubleResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt16());
object shortResult = typeof(Vector256<Int16>)
- .GetMethod(nameof(Vector256<Int16>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<short>)(shortResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt16());
object intResult = typeof(Vector256<Int16>)
- .GetMethod(nameof(Vector256<Int16>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<int>)(intResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt16());
object longResult = typeof(Vector256<Int16>)
- .GetMethod(nameof(Vector256<Int16>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<long>)(longResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt16());
object sbyteResult = typeof(Vector256<Int16>)
- .GetMethod(nameof(Vector256<Int16>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector256.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<sbyte>)(sbyteResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt16());
object floatResult = typeof(Vector256<Int16>)
- .GetMethod(nameof(Vector256<Int16>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector256.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<float>)(floatResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt16());
object ushortResult = typeof(Vector256<Int16>)
- .GetMethod(nameof(Vector256<Int16>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<ushort>)(ushortResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt16());
object uintResult = typeof(Vector256<Int16>)
- .GetMethod(nameof(Vector256<Int16>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<uint>)(uintResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt16());
object ulongResult = typeof(Vector256<Int16>)
- .GetMethod(nameof(Vector256<Int16>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<ulong>)(ulongResult), value);
}
Vector256<Int32> value;
value = Vector256.Create(TestLibrary.Generator.GetInt32());
- Vector256<byte> byteResult = value.As<byte>();
+ Vector256<byte> byteResult = value.As<Int32, byte>();
ValidateResult(byteResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt32());
- Vector256<double> doubleResult = value.As<double>();
+ Vector256<double> doubleResult = value.As<Int32, double>();
ValidateResult(doubleResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt32());
- Vector256<short> shortResult = value.As<short>();
+ Vector256<short> shortResult = value.As<Int32, short>();
ValidateResult(shortResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt32());
- Vector256<int> intResult = value.As<int>();
+ Vector256<int> intResult = value.As<Int32, int>();
ValidateResult(intResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt32());
- Vector256<long> longResult = value.As<long>();
+ Vector256<long> longResult = value.As<Int32, long>();
ValidateResult(longResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt32());
- Vector256<sbyte> sbyteResult = value.As<sbyte>();
+ Vector256<sbyte> sbyteResult = value.As<Int32, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt32());
- Vector256<float> floatResult = value.As<float>();
+ Vector256<float> floatResult = value.As<Int32, float>();
ValidateResult(floatResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt32());
- Vector256<ushort> ushortResult = value.As<ushort>();
+ Vector256<ushort> ushortResult = value.As<Int32, ushort>();
ValidateResult(ushortResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt32());
- Vector256<uint> uintResult = value.As<uint>();
+ Vector256<uint> uintResult = value.As<Int32, uint>();
ValidateResult(uintResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt32());
- Vector256<ulong> ulongResult = value.As<ulong>();
+ Vector256<ulong> ulongResult = value.As<Int32, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector256.Create(TestLibrary.Generator.GetInt32());
object byteResult = typeof(Vector256<Int32>)
- .GetMethod(nameof(Vector256<Int32>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector256.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<byte>)(byteResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt32());
object doubleResult = typeof(Vector256<Int32>)
- .GetMethod(nameof(Vector256<Int32>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector256.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<double>)(doubleResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt32());
object shortResult = typeof(Vector256<Int32>)
- .GetMethod(nameof(Vector256<Int32>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<short>)(shortResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt32());
object intResult = typeof(Vector256<Int32>)
- .GetMethod(nameof(Vector256<Int32>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<int>)(intResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt32());
object longResult = typeof(Vector256<Int32>)
- .GetMethod(nameof(Vector256<Int32>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<long>)(longResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt32());
object sbyteResult = typeof(Vector256<Int32>)
- .GetMethod(nameof(Vector256<Int32>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector256.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<sbyte>)(sbyteResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt32());
object floatResult = typeof(Vector256<Int32>)
- .GetMethod(nameof(Vector256<Int32>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector256.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<float>)(floatResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt32());
object ushortResult = typeof(Vector256<Int32>)
- .GetMethod(nameof(Vector256<Int32>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<ushort>)(ushortResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt32());
object uintResult = typeof(Vector256<Int32>)
- .GetMethod(nameof(Vector256<Int32>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<uint>)(uintResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt32());
object ulongResult = typeof(Vector256<Int32>)
- .GetMethod(nameof(Vector256<Int32>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<ulong>)(ulongResult), value);
}
Vector256<Int64> value;
value = Vector256.Create(TestLibrary.Generator.GetInt64());
- Vector256<byte> byteResult = value.As<byte>();
+ Vector256<byte> byteResult = value.As<Int64, byte>();
ValidateResult(byteResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt64());
- Vector256<double> doubleResult = value.As<double>();
+ Vector256<double> doubleResult = value.As<Int64, double>();
ValidateResult(doubleResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt64());
- Vector256<short> shortResult = value.As<short>();
+ Vector256<short> shortResult = value.As<Int64, short>();
ValidateResult(shortResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt64());
- Vector256<int> intResult = value.As<int>();
+ Vector256<int> intResult = value.As<Int64, int>();
ValidateResult(intResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt64());
- Vector256<long> longResult = value.As<long>();
+ Vector256<long> longResult = value.As<Int64, long>();
ValidateResult(longResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt64());
- Vector256<sbyte> sbyteResult = value.As<sbyte>();
+ Vector256<sbyte> sbyteResult = value.As<Int64, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt64());
- Vector256<float> floatResult = value.As<float>();
+ Vector256<float> floatResult = value.As<Int64, float>();
ValidateResult(floatResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt64());
- Vector256<ushort> ushortResult = value.As<ushort>();
+ Vector256<ushort> ushortResult = value.As<Int64, ushort>();
ValidateResult(ushortResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt64());
- Vector256<uint> uintResult = value.As<uint>();
+ Vector256<uint> uintResult = value.As<Int64, uint>();
ValidateResult(uintResult, value);
value = Vector256.Create(TestLibrary.Generator.GetInt64());
- Vector256<ulong> ulongResult = value.As<ulong>();
+ Vector256<ulong> ulongResult = value.As<Int64, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector256.Create(TestLibrary.Generator.GetInt64());
object byteResult = typeof(Vector256<Int64>)
- .GetMethod(nameof(Vector256<Int64>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector256.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<byte>)(byteResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt64());
object doubleResult = typeof(Vector256<Int64>)
- .GetMethod(nameof(Vector256<Int64>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector256.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<double>)(doubleResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt64());
object shortResult = typeof(Vector256<Int64>)
- .GetMethod(nameof(Vector256<Int64>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<short>)(shortResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt64());
object intResult = typeof(Vector256<Int64>)
- .GetMethod(nameof(Vector256<Int64>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<int>)(intResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt64());
object longResult = typeof(Vector256<Int64>)
- .GetMethod(nameof(Vector256<Int64>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<long>)(longResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt64());
object sbyteResult = typeof(Vector256<Int64>)
- .GetMethod(nameof(Vector256<Int64>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector256.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<sbyte>)(sbyteResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt64());
object floatResult = typeof(Vector256<Int64>)
- .GetMethod(nameof(Vector256<Int64>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector256.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<float>)(floatResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt64());
object ushortResult = typeof(Vector256<Int64>)
- .GetMethod(nameof(Vector256<Int64>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<ushort>)(ushortResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt64());
object uintResult = typeof(Vector256<Int64>)
- .GetMethod(nameof(Vector256<Int64>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<uint>)(uintResult), value);
value = Vector256.Create(TestLibrary.Generator.GetInt64());
object ulongResult = typeof(Vector256<Int64>)
- .GetMethod(nameof(Vector256<Int64>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<ulong>)(ulongResult), value);
}
Vector256<SByte> value;
value = Vector256.Create(TestLibrary.Generator.GetSByte());
- Vector256<byte> byteResult = value.As<byte>();
+ Vector256<byte> byteResult = value.As<SByte, byte>();
ValidateResult(byteResult, value);
value = Vector256.Create(TestLibrary.Generator.GetSByte());
- Vector256<double> doubleResult = value.As<double>();
+ Vector256<double> doubleResult = value.As<SByte, double>();
ValidateResult(doubleResult, value);
value = Vector256.Create(TestLibrary.Generator.GetSByte());
- Vector256<short> shortResult = value.As<short>();
+ Vector256<short> shortResult = value.As<SByte, short>();
ValidateResult(shortResult, value);
value = Vector256.Create(TestLibrary.Generator.GetSByte());
- Vector256<int> intResult = value.As<int>();
+ Vector256<int> intResult = value.As<SByte, int>();
ValidateResult(intResult, value);
value = Vector256.Create(TestLibrary.Generator.GetSByte());
- Vector256<long> longResult = value.As<long>();
+ Vector256<long> longResult = value.As<SByte, long>();
ValidateResult(longResult, value);
value = Vector256.Create(TestLibrary.Generator.GetSByte());
- Vector256<sbyte> sbyteResult = value.As<sbyte>();
+ Vector256<sbyte> sbyteResult = value.As<SByte, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector256.Create(TestLibrary.Generator.GetSByte());
- Vector256<float> floatResult = value.As<float>();
+ Vector256<float> floatResult = value.As<SByte, float>();
ValidateResult(floatResult, value);
value = Vector256.Create(TestLibrary.Generator.GetSByte());
- Vector256<ushort> ushortResult = value.As<ushort>();
+ Vector256<ushort> ushortResult = value.As<SByte, ushort>();
ValidateResult(ushortResult, value);
value = Vector256.Create(TestLibrary.Generator.GetSByte());
- Vector256<uint> uintResult = value.As<uint>();
+ Vector256<uint> uintResult = value.As<SByte, uint>();
ValidateResult(uintResult, value);
value = Vector256.Create(TestLibrary.Generator.GetSByte());
- Vector256<ulong> ulongResult = value.As<ulong>();
+ Vector256<ulong> ulongResult = value.As<SByte, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector256.Create(TestLibrary.Generator.GetSByte());
object byteResult = typeof(Vector256<SByte>)
- .GetMethod(nameof(Vector256<SByte>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector256.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<byte>)(byteResult), value);
value = Vector256.Create(TestLibrary.Generator.GetSByte());
object doubleResult = typeof(Vector256<SByte>)
- .GetMethod(nameof(Vector256<SByte>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector256.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<double>)(doubleResult), value);
value = Vector256.Create(TestLibrary.Generator.GetSByte());
object shortResult = typeof(Vector256<SByte>)
- .GetMethod(nameof(Vector256<SByte>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<short>)(shortResult), value);
value = Vector256.Create(TestLibrary.Generator.GetSByte());
object intResult = typeof(Vector256<SByte>)
- .GetMethod(nameof(Vector256<SByte>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<int>)(intResult), value);
value = Vector256.Create(TestLibrary.Generator.GetSByte());
object longResult = typeof(Vector256<SByte>)
- .GetMethod(nameof(Vector256<SByte>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<long>)(longResult), value);
value = Vector256.Create(TestLibrary.Generator.GetSByte());
object sbyteResult = typeof(Vector256<SByte>)
- .GetMethod(nameof(Vector256<SByte>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector256.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<sbyte>)(sbyteResult), value);
value = Vector256.Create(TestLibrary.Generator.GetSByte());
object floatResult = typeof(Vector256<SByte>)
- .GetMethod(nameof(Vector256<SByte>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector256.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<float>)(floatResult), value);
value = Vector256.Create(TestLibrary.Generator.GetSByte());
object ushortResult = typeof(Vector256<SByte>)
- .GetMethod(nameof(Vector256<SByte>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<ushort>)(ushortResult), value);
value = Vector256.Create(TestLibrary.Generator.GetSByte());
object uintResult = typeof(Vector256<SByte>)
- .GetMethod(nameof(Vector256<SByte>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<uint>)(uintResult), value);
value = Vector256.Create(TestLibrary.Generator.GetSByte());
object ulongResult = typeof(Vector256<SByte>)
- .GetMethod(nameof(Vector256<SByte>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<ulong>)(ulongResult), value);
}
Vector256<Single> value;
value = Vector256.Create(TestLibrary.Generator.GetSingle());
- Vector256<byte> byteResult = value.As<byte>();
+ Vector256<byte> byteResult = value.As<Single, byte>();
ValidateResult(byteResult, value);
value = Vector256.Create(TestLibrary.Generator.GetSingle());
- Vector256<double> doubleResult = value.As<double>();
+ Vector256<double> doubleResult = value.As<Single, double>();
ValidateResult(doubleResult, value);
value = Vector256.Create(TestLibrary.Generator.GetSingle());
- Vector256<short> shortResult = value.As<short>();
+ Vector256<short> shortResult = value.As<Single, short>();
ValidateResult(shortResult, value);
value = Vector256.Create(TestLibrary.Generator.GetSingle());
- Vector256<int> intResult = value.As<int>();
+ Vector256<int> intResult = value.As<Single, int>();
ValidateResult(intResult, value);
value = Vector256.Create(TestLibrary.Generator.GetSingle());
- Vector256<long> longResult = value.As<long>();
+ Vector256<long> longResult = value.As<Single, long>();
ValidateResult(longResult, value);
value = Vector256.Create(TestLibrary.Generator.GetSingle());
- Vector256<sbyte> sbyteResult = value.As<sbyte>();
+ Vector256<sbyte> sbyteResult = value.As<Single, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector256.Create(TestLibrary.Generator.GetSingle());
- Vector256<float> floatResult = value.As<float>();
+ Vector256<float> floatResult = value.As<Single, float>();
ValidateResult(floatResult, value);
value = Vector256.Create(TestLibrary.Generator.GetSingle());
- Vector256<ushort> ushortResult = value.As<ushort>();
+ Vector256<ushort> ushortResult = value.As<Single, ushort>();
ValidateResult(ushortResult, value);
value = Vector256.Create(TestLibrary.Generator.GetSingle());
- Vector256<uint> uintResult = value.As<uint>();
+ Vector256<uint> uintResult = value.As<Single, uint>();
ValidateResult(uintResult, value);
value = Vector256.Create(TestLibrary.Generator.GetSingle());
- Vector256<ulong> ulongResult = value.As<ulong>();
+ Vector256<ulong> ulongResult = value.As<Single, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector256.Create(TestLibrary.Generator.GetSingle());
object byteResult = typeof(Vector256<Single>)
- .GetMethod(nameof(Vector256<Single>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector256.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<byte>)(byteResult), value);
value = Vector256.Create(TestLibrary.Generator.GetSingle());
object doubleResult = typeof(Vector256<Single>)
- .GetMethod(nameof(Vector256<Single>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector256.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<double>)(doubleResult), value);
value = Vector256.Create(TestLibrary.Generator.GetSingle());
object shortResult = typeof(Vector256<Single>)
- .GetMethod(nameof(Vector256<Single>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<short>)(shortResult), value);
value = Vector256.Create(TestLibrary.Generator.GetSingle());
object intResult = typeof(Vector256<Single>)
- .GetMethod(nameof(Vector256<Single>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<int>)(intResult), value);
value = Vector256.Create(TestLibrary.Generator.GetSingle());
object longResult = typeof(Vector256<Single>)
- .GetMethod(nameof(Vector256<Single>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<long>)(longResult), value);
value = Vector256.Create(TestLibrary.Generator.GetSingle());
object sbyteResult = typeof(Vector256<Single>)
- .GetMethod(nameof(Vector256<Single>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector256.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<sbyte>)(sbyteResult), value);
value = Vector256.Create(TestLibrary.Generator.GetSingle());
object floatResult = typeof(Vector256<Single>)
- .GetMethod(nameof(Vector256<Single>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector256.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<float>)(floatResult), value);
value = Vector256.Create(TestLibrary.Generator.GetSingle());
object ushortResult = typeof(Vector256<Single>)
- .GetMethod(nameof(Vector256<Single>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<ushort>)(ushortResult), value);
value = Vector256.Create(TestLibrary.Generator.GetSingle());
object uintResult = typeof(Vector256<Single>)
- .GetMethod(nameof(Vector256<Single>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<uint>)(uintResult), value);
value = Vector256.Create(TestLibrary.Generator.GetSingle());
object ulongResult = typeof(Vector256<Single>)
- .GetMethod(nameof(Vector256<Single>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<ulong>)(ulongResult), value);
}
Vector256<UInt16> value;
value = Vector256.Create(TestLibrary.Generator.GetUInt16());
- Vector256<byte> byteResult = value.As<byte>();
+ Vector256<byte> byteResult = value.As<UInt16, byte>();
ValidateResult(byteResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt16());
- Vector256<double> doubleResult = value.As<double>();
+ Vector256<double> doubleResult = value.As<UInt16, double>();
ValidateResult(doubleResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt16());
- Vector256<short> shortResult = value.As<short>();
+ Vector256<short> shortResult = value.As<UInt16, short>();
ValidateResult(shortResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt16());
- Vector256<int> intResult = value.As<int>();
+ Vector256<int> intResult = value.As<UInt16, int>();
ValidateResult(intResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt16());
- Vector256<long> longResult = value.As<long>();
+ Vector256<long> longResult = value.As<UInt16, long>();
ValidateResult(longResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt16());
- Vector256<sbyte> sbyteResult = value.As<sbyte>();
+ Vector256<sbyte> sbyteResult = value.As<UInt16, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt16());
- Vector256<float> floatResult = value.As<float>();
+ Vector256<float> floatResult = value.As<UInt16, float>();
ValidateResult(floatResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt16());
- Vector256<ushort> ushortResult = value.As<ushort>();
+ Vector256<ushort> ushortResult = value.As<UInt16, ushort>();
ValidateResult(ushortResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt16());
- Vector256<uint> uintResult = value.As<uint>();
+ Vector256<uint> uintResult = value.As<UInt16, uint>();
ValidateResult(uintResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt16());
- Vector256<ulong> ulongResult = value.As<ulong>();
+ Vector256<ulong> ulongResult = value.As<UInt16, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector256.Create(TestLibrary.Generator.GetUInt16());
object byteResult = typeof(Vector256<UInt16>)
- .GetMethod(nameof(Vector256<UInt16>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector256.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<byte>)(byteResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt16());
object doubleResult = typeof(Vector256<UInt16>)
- .GetMethod(nameof(Vector256<UInt16>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector256.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<double>)(doubleResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt16());
object shortResult = typeof(Vector256<UInt16>)
- .GetMethod(nameof(Vector256<UInt16>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<short>)(shortResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt16());
object intResult = typeof(Vector256<UInt16>)
- .GetMethod(nameof(Vector256<UInt16>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<int>)(intResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt16());
object longResult = typeof(Vector256<UInt16>)
- .GetMethod(nameof(Vector256<UInt16>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<long>)(longResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt16());
object sbyteResult = typeof(Vector256<UInt16>)
- .GetMethod(nameof(Vector256<UInt16>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector256.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<sbyte>)(sbyteResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt16());
object floatResult = typeof(Vector256<UInt16>)
- .GetMethod(nameof(Vector256<UInt16>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector256.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<float>)(floatResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt16());
object ushortResult = typeof(Vector256<UInt16>)
- .GetMethod(nameof(Vector256<UInt16>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<ushort>)(ushortResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt16());
object uintResult = typeof(Vector256<UInt16>)
- .GetMethod(nameof(Vector256<UInt16>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<uint>)(uintResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt16());
object ulongResult = typeof(Vector256<UInt16>)
- .GetMethod(nameof(Vector256<UInt16>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<ulong>)(ulongResult), value);
}
Vector256<UInt32> value;
value = Vector256.Create(TestLibrary.Generator.GetUInt32());
- Vector256<byte> byteResult = value.As<byte>();
+ Vector256<byte> byteResult = value.As<UInt32, byte>();
ValidateResult(byteResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt32());
- Vector256<double> doubleResult = value.As<double>();
+ Vector256<double> doubleResult = value.As<UInt32, double>();
ValidateResult(doubleResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt32());
- Vector256<short> shortResult = value.As<short>();
+ Vector256<short> shortResult = value.As<UInt32, short>();
ValidateResult(shortResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt32());
- Vector256<int> intResult = value.As<int>();
+ Vector256<int> intResult = value.As<UInt32, int>();
ValidateResult(intResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt32());
- Vector256<long> longResult = value.As<long>();
+ Vector256<long> longResult = value.As<UInt32, long>();
ValidateResult(longResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt32());
- Vector256<sbyte> sbyteResult = value.As<sbyte>();
+ Vector256<sbyte> sbyteResult = value.As<UInt32, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt32());
- Vector256<float> floatResult = value.As<float>();
+ Vector256<float> floatResult = value.As<UInt32, float>();
ValidateResult(floatResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt32());
- Vector256<ushort> ushortResult = value.As<ushort>();
+ Vector256<ushort> ushortResult = value.As<UInt32, ushort>();
ValidateResult(ushortResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt32());
- Vector256<uint> uintResult = value.As<uint>();
+ Vector256<uint> uintResult = value.As<UInt32, uint>();
ValidateResult(uintResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt32());
- Vector256<ulong> ulongResult = value.As<ulong>();
+ Vector256<ulong> ulongResult = value.As<UInt32, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector256.Create(TestLibrary.Generator.GetUInt32());
object byteResult = typeof(Vector256<UInt32>)
- .GetMethod(nameof(Vector256<UInt32>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector256.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<byte>)(byteResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt32());
object doubleResult = typeof(Vector256<UInt32>)
- .GetMethod(nameof(Vector256<UInt32>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector256.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<double>)(doubleResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt32());
object shortResult = typeof(Vector256<UInt32>)
- .GetMethod(nameof(Vector256<UInt32>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<short>)(shortResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt32());
object intResult = typeof(Vector256<UInt32>)
- .GetMethod(nameof(Vector256<UInt32>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<int>)(intResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt32());
object longResult = typeof(Vector256<UInt32>)
- .GetMethod(nameof(Vector256<UInt32>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<long>)(longResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt32());
object sbyteResult = typeof(Vector256<UInt32>)
- .GetMethod(nameof(Vector256<UInt32>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector256.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<sbyte>)(sbyteResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt32());
object floatResult = typeof(Vector256<UInt32>)
- .GetMethod(nameof(Vector256<UInt32>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector256.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<float>)(floatResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt32());
object ushortResult = typeof(Vector256<UInt32>)
- .GetMethod(nameof(Vector256<UInt32>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<ushort>)(ushortResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt32());
object uintResult = typeof(Vector256<UInt32>)
- .GetMethod(nameof(Vector256<UInt32>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<uint>)(uintResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt32());
object ulongResult = typeof(Vector256<UInt32>)
- .GetMethod(nameof(Vector256<UInt32>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<ulong>)(ulongResult), value);
}
Vector256<UInt64> value;
value = Vector256.Create(TestLibrary.Generator.GetUInt64());
- Vector256<byte> byteResult = value.As<byte>();
+ Vector256<byte> byteResult = value.As<UInt64, byte>();
ValidateResult(byteResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt64());
- Vector256<double> doubleResult = value.As<double>();
+ Vector256<double> doubleResult = value.As<UInt64, double>();
ValidateResult(doubleResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt64());
- Vector256<short> shortResult = value.As<short>();
+ Vector256<short> shortResult = value.As<UInt64, short>();
ValidateResult(shortResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt64());
- Vector256<int> intResult = value.As<int>();
+ Vector256<int> intResult = value.As<UInt64, int>();
ValidateResult(intResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt64());
- Vector256<long> longResult = value.As<long>();
+ Vector256<long> longResult = value.As<UInt64, long>();
ValidateResult(longResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt64());
- Vector256<sbyte> sbyteResult = value.As<sbyte>();
+ Vector256<sbyte> sbyteResult = value.As<UInt64, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt64());
- Vector256<float> floatResult = value.As<float>();
+ Vector256<float> floatResult = value.As<UInt64, float>();
ValidateResult(floatResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt64());
- Vector256<ushort> ushortResult = value.As<ushort>();
+ Vector256<ushort> ushortResult = value.As<UInt64, ushort>();
ValidateResult(ushortResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt64());
- Vector256<uint> uintResult = value.As<uint>();
+ Vector256<uint> uintResult = value.As<UInt64, uint>();
ValidateResult(uintResult, value);
value = Vector256.Create(TestLibrary.Generator.GetUInt64());
- Vector256<ulong> ulongResult = value.As<ulong>();
+ Vector256<ulong> ulongResult = value.As<UInt64, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector256.Create(TestLibrary.Generator.GetUInt64());
object byteResult = typeof(Vector256<UInt64>)
- .GetMethod(nameof(Vector256<UInt64>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector256.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<byte>)(byteResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt64());
object doubleResult = typeof(Vector256<UInt64>)
- .GetMethod(nameof(Vector256<UInt64>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector256.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<double>)(doubleResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt64());
object shortResult = typeof(Vector256<UInt64>)
- .GetMethod(nameof(Vector256<UInt64>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<short>)(shortResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt64());
object intResult = typeof(Vector256<UInt64>)
- .GetMethod(nameof(Vector256<UInt64>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<int>)(intResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt64());
object longResult = typeof(Vector256<UInt64>)
- .GetMethod(nameof(Vector256<UInt64>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector256.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<long>)(longResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt64());
object sbyteResult = typeof(Vector256<UInt64>)
- .GetMethod(nameof(Vector256<UInt64>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector256.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<sbyte>)(sbyteResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt64());
object floatResult = typeof(Vector256<UInt64>)
- .GetMethod(nameof(Vector256<UInt64>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector256.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<float>)(floatResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt64());
object ushortResult = typeof(Vector256<UInt64>)
- .GetMethod(nameof(Vector256<UInt64>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<ushort>)(ushortResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt64());
object uintResult = typeof(Vector256<UInt64>)
- .GetMethod(nameof(Vector256<UInt64>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<uint>)(uintResult), value);
value = Vector256.Create(TestLibrary.Generator.GetUInt64());
object ulongResult = typeof(Vector256<UInt64>)
- .GetMethod(nameof(Vector256<UInt64>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector256.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector256<ulong>)(ulongResult), value);
}
try
{
object result = typeof(Vector256<Byte>)
- .GetMethod(nameof(Vector256<Byte>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Byte)(result), values);
}
try
{
object result2 = typeof(Vector256<Byte>)
- .GetMethod(nameof(Vector256<Byte>.WithElement), new Type[] { typeof(int), typeof(Byte) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(Byte) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<Byte>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<Byte>)
- .GetMethod(nameof(Vector256<Byte>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Byte)(result), values);
}
try
{
object result2 = typeof(Vector256<Byte>)
- .GetMethod(nameof(Vector256<Byte>.WithElement), new Type[] { typeof(int), typeof(Byte) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(Byte) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<Byte>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<Byte>)
- .GetMethod(nameof(Vector256<Byte>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Byte)(result), values);
}
try
{
object result2 = typeof(Vector256<Byte>)
- .GetMethod(nameof(Vector256<Byte>.WithElement), new Type[] { typeof(int), typeof(Byte) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(Byte) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<Byte>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<Byte>)
- .GetMethod(nameof(Vector256<Byte>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Byte)(result), values);
}
try
{
object result2 = typeof(Vector256<Byte>)
- .GetMethod(nameof(Vector256<Byte>.WithElement), new Type[] { typeof(int), typeof(Byte) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(Byte) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<Byte>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<Double>)
- .GetMethod(nameof(Vector256<Double>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Double)(result), values);
}
try
{
object result2 = typeof(Vector256<Double>)
- .GetMethod(nameof(Vector256<Double>.WithElement), new Type[] { typeof(int), typeof(Double) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(Double) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<Double>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<Double>)
- .GetMethod(nameof(Vector256<Double>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Double)(result), values);
}
try
{
object result2 = typeof(Vector256<Double>)
- .GetMethod(nameof(Vector256<Double>.WithElement), new Type[] { typeof(int), typeof(Double) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(Double) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<Double>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<Double>)
- .GetMethod(nameof(Vector256<Double>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Double)(result), values);
}
try
{
object result2 = typeof(Vector256<Double>)
- .GetMethod(nameof(Vector256<Double>.WithElement), new Type[] { typeof(int), typeof(Double) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(Double) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<Double>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<Int16>)
- .GetMethod(nameof(Vector256<Int16>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int16)(result), values);
}
try
{
object result2 = typeof(Vector256<Int16>)
- .GetMethod(nameof(Vector256<Int16>.WithElement), new Type[] { typeof(int), typeof(Int16) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(Int16) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<Int16>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<Int16>)
- .GetMethod(nameof(Vector256<Int16>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int16)(result), values);
}
try
{
object result2 = typeof(Vector256<Int16>)
- .GetMethod(nameof(Vector256<Int16>.WithElement), new Type[] { typeof(int), typeof(Int16) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(Int16) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<Int16>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<Int16>)
- .GetMethod(nameof(Vector256<Int16>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int16)(result), values);
}
try
{
object result2 = typeof(Vector256<Int16>)
- .GetMethod(nameof(Vector256<Int16>.WithElement), new Type[] { typeof(int), typeof(Int16) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(Int16) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<Int16>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<Int16>)
- .GetMethod(nameof(Vector256<Int16>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int16)(result), values);
}
try
{
object result2 = typeof(Vector256<Int16>)
- .GetMethod(nameof(Vector256<Int16>.WithElement), new Type[] { typeof(int), typeof(Int16) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(Int16) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<Int16>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<Int32>)
- .GetMethod(nameof(Vector256<Int32>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int32)(result), values);
}
try
{
object result2 = typeof(Vector256<Int32>)
- .GetMethod(nameof(Vector256<Int32>.WithElement), new Type[] { typeof(int), typeof(Int32) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(Int32) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<Int32>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<Int32>)
- .GetMethod(nameof(Vector256<Int32>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int32)(result), values);
}
try
{
object result2 = typeof(Vector256<Int32>)
- .GetMethod(nameof(Vector256<Int32>.WithElement), new Type[] { typeof(int), typeof(Int32) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(Int32) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<Int32>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<Int32>)
- .GetMethod(nameof(Vector256<Int32>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int32)(result), values);
}
try
{
object result2 = typeof(Vector256<Int32>)
- .GetMethod(nameof(Vector256<Int32>.WithElement), new Type[] { typeof(int), typeof(Int32) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(Int32) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<Int32>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<Int32>)
- .GetMethod(nameof(Vector256<Int32>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int32)(result), values);
}
try
{
object result2 = typeof(Vector256<Int32>)
- .GetMethod(nameof(Vector256<Int32>.WithElement), new Type[] { typeof(int), typeof(Int32) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(Int32) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<Int32>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<Int64>)
- .GetMethod(nameof(Vector256<Int64>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int64)(result), values);
}
try
{
object result2 = typeof(Vector256<Int64>)
- .GetMethod(nameof(Vector256<Int64>.WithElement), new Type[] { typeof(int), typeof(Int64) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(Int64) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<Int64>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<Int64>)
- .GetMethod(nameof(Vector256<Int64>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int64)(result), values);
}
try
{
object result2 = typeof(Vector256<Int64>)
- .GetMethod(nameof(Vector256<Int64>.WithElement), new Type[] { typeof(int), typeof(Int64) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(Int64) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<Int64>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<Int64>)
- .GetMethod(nameof(Vector256<Int64>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int64)(result), values);
}
try
{
object result2 = typeof(Vector256<Int64>)
- .GetMethod(nameof(Vector256<Int64>.WithElement), new Type[] { typeof(int), typeof(Int64) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(Int64) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<Int64>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<SByte>)
- .GetMethod(nameof(Vector256<SByte>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((SByte)(result), values);
}
try
{
object result2 = typeof(Vector256<SByte>)
- .GetMethod(nameof(Vector256<SByte>.WithElement), new Type[] { typeof(int), typeof(SByte) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(SByte) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<SByte>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<SByte>)
- .GetMethod(nameof(Vector256<SByte>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((SByte)(result), values);
}
try
{
object result2 = typeof(Vector256<SByte>)
- .GetMethod(nameof(Vector256<SByte>.WithElement), new Type[] { typeof(int), typeof(SByte) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(SByte) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<SByte>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<SByte>)
- .GetMethod(nameof(Vector256<SByte>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((SByte)(result), values);
}
try
{
object result2 = typeof(Vector256<SByte>)
- .GetMethod(nameof(Vector256<SByte>.WithElement), new Type[] { typeof(int), typeof(SByte) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(SByte) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<SByte>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<SByte>)
- .GetMethod(nameof(Vector256<SByte>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((SByte)(result), values);
}
try
{
object result2 = typeof(Vector256<SByte>)
- .GetMethod(nameof(Vector256<SByte>.WithElement), new Type[] { typeof(int), typeof(SByte) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(SByte) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<SByte>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<Single>)
- .GetMethod(nameof(Vector256<Single>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Single)(result), values);
}
try
{
object result2 = typeof(Vector256<Single>)
- .GetMethod(nameof(Vector256<Single>.WithElement), new Type[] { typeof(int), typeof(Single) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(Single) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<Single>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<Single>)
- .GetMethod(nameof(Vector256<Single>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Single)(result), values);
}
try
{
object result2 = typeof(Vector256<Single>)
- .GetMethod(nameof(Vector256<Single>.WithElement), new Type[] { typeof(int), typeof(Single) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(Single) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<Single>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<Single>)
- .GetMethod(nameof(Vector256<Single>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Single)(result), values);
}
try
{
object result2 = typeof(Vector256<Single>)
- .GetMethod(nameof(Vector256<Single>.WithElement), new Type[] { typeof(int), typeof(Single) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(Single) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<Single>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<Single>)
- .GetMethod(nameof(Vector256<Single>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Single)(result), values);
}
try
{
object result2 = typeof(Vector256<Single>)
- .GetMethod(nameof(Vector256<Single>.WithElement), new Type[] { typeof(int), typeof(Single) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(Single) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<Single>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<UInt16>)
- .GetMethod(nameof(Vector256<UInt16>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt16)(result), values);
}
try
{
object result2 = typeof(Vector256<UInt16>)
- .GetMethod(nameof(Vector256<UInt16>.WithElement), new Type[] { typeof(int), typeof(UInt16) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(UInt16) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<UInt16>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<UInt16>)
- .GetMethod(nameof(Vector256<UInt16>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt16)(result), values);
}
try
{
object result2 = typeof(Vector256<UInt16>)
- .GetMethod(nameof(Vector256<UInt16>.WithElement), new Type[] { typeof(int), typeof(UInt16) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(UInt16) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<UInt16>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<UInt16>)
- .GetMethod(nameof(Vector256<UInt16>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt16)(result), values);
}
try
{
object result2 = typeof(Vector256<UInt16>)
- .GetMethod(nameof(Vector256<UInt16>.WithElement), new Type[] { typeof(int), typeof(UInt16) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(UInt16) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<UInt16>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<UInt16>)
- .GetMethod(nameof(Vector256<UInt16>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt16)(result), values);
}
try
{
object result2 = typeof(Vector256<UInt16>)
- .GetMethod(nameof(Vector256<UInt16>.WithElement), new Type[] { typeof(int), typeof(UInt16) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(UInt16) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<UInt16>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<UInt32>)
- .GetMethod(nameof(Vector256<UInt32>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt32)(result), values);
}
try
{
object result2 = typeof(Vector256<UInt32>)
- .GetMethod(nameof(Vector256<UInt32>.WithElement), new Type[] { typeof(int), typeof(UInt32) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(UInt32) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<UInt32>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<UInt32>)
- .GetMethod(nameof(Vector256<UInt32>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt32)(result), values);
}
try
{
object result2 = typeof(Vector256<UInt32>)
- .GetMethod(nameof(Vector256<UInt32>.WithElement), new Type[] { typeof(int), typeof(UInt32) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(UInt32) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<UInt32>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<UInt32>)
- .GetMethod(nameof(Vector256<UInt32>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt32)(result), values);
}
try
{
object result2 = typeof(Vector256<UInt32>)
- .GetMethod(nameof(Vector256<UInt32>.WithElement), new Type[] { typeof(int), typeof(UInt32) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(UInt32) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<UInt32>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<UInt32>)
- .GetMethod(nameof(Vector256<UInt32>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt32)(result), values);
}
try
{
object result2 = typeof(Vector256<UInt32>)
- .GetMethod(nameof(Vector256<UInt32>.WithElement), new Type[] { typeof(int), typeof(UInt32) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(UInt32) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<UInt32>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<UInt64>)
- .GetMethod(nameof(Vector256<UInt64>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt64)(result), values);
}
try
{
object result2 = typeof(Vector256<UInt64>)
- .GetMethod(nameof(Vector256<UInt64>.WithElement), new Type[] { typeof(int), typeof(UInt64) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(UInt64) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<UInt64>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<UInt64>)
- .GetMethod(nameof(Vector256<UInt64>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt64)(result), values);
}
try
{
object result2 = typeof(Vector256<UInt64>)
- .GetMethod(nameof(Vector256<UInt64>.WithElement), new Type[] { typeof(int), typeof(UInt64) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(UInt64) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<UInt64>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector256<UInt64>)
- .GetMethod(nameof(Vector256<UInt64>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector256.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt64)(result), values);
}
try
{
object result2 = typeof(Vector256<UInt64>)
- .GetMethod(nameof(Vector256<UInt64>.WithElement), new Type[] { typeof(int), typeof(UInt64) })
+ .GetMethod(nameof(Vector256.WithElement), new Type[] { typeof(int), typeof(UInt64) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector256<UInt64>)(result2), values, insertedValue);
}
Vector256<Byte> value = Vector256.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31]);
object lowerResult = typeof(Vector256<Byte>)
- .GetMethod(nameof(Vector256<Byte>.GetLower), new Type[] { })
+ .GetMethod(nameof(Vector256.GetLower), new Type[] { })
.Invoke(value, new object[] { });
object upperResult = typeof(Vector256<Byte>)
- .GetMethod(nameof(Vector256<Byte>.GetUpper), new Type[] { })
+ .GetMethod(nameof(Vector256.GetUpper), new Type[] { })
.Invoke(value, new object[] { });
ValidateGetResult((Vector128<Byte>)(lowerResult), (Vector128<Byte>)(upperResult), values);
object result = typeof(Vector256<Byte>)
- .GetMethod(nameof(Vector256<Byte>.WithLower), new Type[] { typeof(Vector128<Byte>) })
+ .GetMethod(nameof(Vector256.WithLower), new Type[] { typeof(Vector128<Byte>) })
.Invoke(value, new object[] { upperResult });
result = typeof(Vector256<Byte>)
- .GetMethod(nameof(Vector256<Byte>.WithUpper), new Type[] { typeof(Vector128<Byte>) })
+ .GetMethod(nameof(Vector256.WithUpper), new Type[] { typeof(Vector128<Byte>) })
.Invoke(result, new object[] { lowerResult });
ValidateWithResult((Vector256<Byte>)(result), values);
}
Vector256<Double> value = Vector256.Create(values[0], values[1], values[2], values[3]);
object lowerResult = typeof(Vector256<Double>)
- .GetMethod(nameof(Vector256<Double>.GetLower), new Type[] { })
+ .GetMethod(nameof(Vector256.GetLower), new Type[] { })
.Invoke(value, new object[] { });
object upperResult = typeof(Vector256<Double>)
- .GetMethod(nameof(Vector256<Double>.GetUpper), new Type[] { })
+ .GetMethod(nameof(Vector256.GetUpper), new Type[] { })
.Invoke(value, new object[] { });
ValidateGetResult((Vector128<Double>)(lowerResult), (Vector128<Double>)(upperResult), values);
object result = typeof(Vector256<Double>)
- .GetMethod(nameof(Vector256<Double>.WithLower), new Type[] { typeof(Vector128<Double>) })
+ .GetMethod(nameof(Vector256.WithLower), new Type[] { typeof(Vector128<Double>) })
.Invoke(value, new object[] { upperResult });
result = typeof(Vector256<Double>)
- .GetMethod(nameof(Vector256<Double>.WithUpper), new Type[] { typeof(Vector128<Double>) })
+ .GetMethod(nameof(Vector256.WithUpper), new Type[] { typeof(Vector128<Double>) })
.Invoke(result, new object[] { lowerResult });
ValidateWithResult((Vector256<Double>)(result), values);
}
Vector256<Int16> value = Vector256.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]);
object lowerResult = typeof(Vector256<Int16>)
- .GetMethod(nameof(Vector256<Int16>.GetLower), new Type[] { })
+ .GetMethod(nameof(Vector256.GetLower), new Type[] { })
.Invoke(value, new object[] { });
object upperResult = typeof(Vector256<Int16>)
- .GetMethod(nameof(Vector256<Int16>.GetUpper), new Type[] { })
+ .GetMethod(nameof(Vector256.GetUpper), new Type[] { })
.Invoke(value, new object[] { });
ValidateGetResult((Vector128<Int16>)(lowerResult), (Vector128<Int16>)(upperResult), values);
object result = typeof(Vector256<Int16>)
- .GetMethod(nameof(Vector256<Int16>.WithLower), new Type[] { typeof(Vector128<Int16>) })
+ .GetMethod(nameof(Vector256.WithLower), new Type[] { typeof(Vector128<Int16>) })
.Invoke(value, new object[] { upperResult });
result = typeof(Vector256<Int16>)
- .GetMethod(nameof(Vector256<Int16>.WithUpper), new Type[] { typeof(Vector128<Int16>) })
+ .GetMethod(nameof(Vector256.WithUpper), new Type[] { typeof(Vector128<Int16>) })
.Invoke(result, new object[] { lowerResult });
ValidateWithResult((Vector256<Int16>)(result), values);
}
Vector256<Int32> value = Vector256.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]);
object lowerResult = typeof(Vector256<Int32>)
- .GetMethod(nameof(Vector256<Int32>.GetLower), new Type[] { })
+ .GetMethod(nameof(Vector256.GetLower), new Type[] { })
.Invoke(value, new object[] { });
object upperResult = typeof(Vector256<Int32>)
- .GetMethod(nameof(Vector256<Int32>.GetUpper), new Type[] { })
+ .GetMethod(nameof(Vector256.GetUpper), new Type[] { })
.Invoke(value, new object[] { });
ValidateGetResult((Vector128<Int32>)(lowerResult), (Vector128<Int32>)(upperResult), values);
object result = typeof(Vector256<Int32>)
- .GetMethod(nameof(Vector256<Int32>.WithLower), new Type[] { typeof(Vector128<Int32>) })
+ .GetMethod(nameof(Vector256.WithLower), new Type[] { typeof(Vector128<Int32>) })
.Invoke(value, new object[] { upperResult });
result = typeof(Vector256<Int32>)
- .GetMethod(nameof(Vector256<Int32>.WithUpper), new Type[] { typeof(Vector128<Int32>) })
+ .GetMethod(nameof(Vector256.WithUpper), new Type[] { typeof(Vector128<Int32>) })
.Invoke(result, new object[] { lowerResult });
ValidateWithResult((Vector256<Int32>)(result), values);
}
Vector256<Int64> value = Vector256.Create(values[0], values[1], values[2], values[3]);
object lowerResult = typeof(Vector256<Int64>)
- .GetMethod(nameof(Vector256<Int64>.GetLower), new Type[] { })
+ .GetMethod(nameof(Vector256.GetLower), new Type[] { })
.Invoke(value, new object[] { });
object upperResult = typeof(Vector256<Int64>)
- .GetMethod(nameof(Vector256<Int64>.GetUpper), new Type[] { })
+ .GetMethod(nameof(Vector256.GetUpper), new Type[] { })
.Invoke(value, new object[] { });
ValidateGetResult((Vector128<Int64>)(lowerResult), (Vector128<Int64>)(upperResult), values);
object result = typeof(Vector256<Int64>)
- .GetMethod(nameof(Vector256<Int64>.WithLower), new Type[] { typeof(Vector128<Int64>) })
+ .GetMethod(nameof(Vector256.WithLower), new Type[] { typeof(Vector128<Int64>) })
.Invoke(value, new object[] { upperResult });
result = typeof(Vector256<Int64>)
- .GetMethod(nameof(Vector256<Int64>.WithUpper), new Type[] { typeof(Vector128<Int64>) })
+ .GetMethod(nameof(Vector256.WithUpper), new Type[] { typeof(Vector128<Int64>) })
.Invoke(result, new object[] { lowerResult });
ValidateWithResult((Vector256<Int64>)(result), values);
}
Vector256<SByte> value = Vector256.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31]);
object lowerResult = typeof(Vector256<SByte>)
- .GetMethod(nameof(Vector256<SByte>.GetLower), new Type[] { })
+ .GetMethod(nameof(Vector256.GetLower), new Type[] { })
.Invoke(value, new object[] { });
object upperResult = typeof(Vector256<SByte>)
- .GetMethod(nameof(Vector256<SByte>.GetUpper), new Type[] { })
+ .GetMethod(nameof(Vector256.GetUpper), new Type[] { })
.Invoke(value, new object[] { });
ValidateGetResult((Vector128<SByte>)(lowerResult), (Vector128<SByte>)(upperResult), values);
object result = typeof(Vector256<SByte>)
- .GetMethod(nameof(Vector256<SByte>.WithLower), new Type[] { typeof(Vector128<SByte>) })
+ .GetMethod(nameof(Vector256.WithLower), new Type[] { typeof(Vector128<SByte>) })
.Invoke(value, new object[] { upperResult });
result = typeof(Vector256<SByte>)
- .GetMethod(nameof(Vector256<SByte>.WithUpper), new Type[] { typeof(Vector128<SByte>) })
+ .GetMethod(nameof(Vector256.WithUpper), new Type[] { typeof(Vector128<SByte>) })
.Invoke(result, new object[] { lowerResult });
ValidateWithResult((Vector256<SByte>)(result), values);
}
Vector256<Single> value = Vector256.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]);
object lowerResult = typeof(Vector256<Single>)
- .GetMethod(nameof(Vector256<Single>.GetLower), new Type[] { })
+ .GetMethod(nameof(Vector256.GetLower), new Type[] { })
.Invoke(value, new object[] { });
object upperResult = typeof(Vector256<Single>)
- .GetMethod(nameof(Vector256<Single>.GetUpper), new Type[] { })
+ .GetMethod(nameof(Vector256.GetUpper), new Type[] { })
.Invoke(value, new object[] { });
ValidateGetResult((Vector128<Single>)(lowerResult), (Vector128<Single>)(upperResult), values);
object result = typeof(Vector256<Single>)
- .GetMethod(nameof(Vector256<Single>.WithLower), new Type[] { typeof(Vector128<Single>) })
+ .GetMethod(nameof(Vector256.WithLower), new Type[] { typeof(Vector128<Single>) })
.Invoke(value, new object[] { upperResult });
result = typeof(Vector256<Single>)
- .GetMethod(nameof(Vector256<Single>.WithUpper), new Type[] { typeof(Vector128<Single>) })
+ .GetMethod(nameof(Vector256.WithUpper), new Type[] { typeof(Vector128<Single>) })
.Invoke(result, new object[] { lowerResult });
ValidateWithResult((Vector256<Single>)(result), values);
}
Vector256<UInt16> value = Vector256.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]);
object lowerResult = typeof(Vector256<UInt16>)
- .GetMethod(nameof(Vector256<UInt16>.GetLower), new Type[] { })
+ .GetMethod(nameof(Vector256.GetLower), new Type[] { })
.Invoke(value, new object[] { });
object upperResult = typeof(Vector256<UInt16>)
- .GetMethod(nameof(Vector256<UInt16>.GetUpper), new Type[] { })
+ .GetMethod(nameof(Vector256.GetUpper), new Type[] { })
.Invoke(value, new object[] { });
ValidateGetResult((Vector128<UInt16>)(lowerResult), (Vector128<UInt16>)(upperResult), values);
object result = typeof(Vector256<UInt16>)
- .GetMethod(nameof(Vector256<UInt16>.WithLower), new Type[] { typeof(Vector128<UInt16>) })
+ .GetMethod(nameof(Vector256.WithLower), new Type[] { typeof(Vector128<UInt16>) })
.Invoke(value, new object[] { upperResult });
result = typeof(Vector256<UInt16>)
- .GetMethod(nameof(Vector256<UInt16>.WithUpper), new Type[] { typeof(Vector128<UInt16>) })
+ .GetMethod(nameof(Vector256.WithUpper), new Type[] { typeof(Vector128<UInt16>) })
.Invoke(result, new object[] { lowerResult });
ValidateWithResult((Vector256<UInt16>)(result), values);
}
Vector256<UInt32> value = Vector256.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]);
object lowerResult = typeof(Vector256<UInt32>)
- .GetMethod(nameof(Vector256<UInt32>.GetLower), new Type[] { })
+ .GetMethod(nameof(Vector256.GetLower), new Type[] { })
.Invoke(value, new object[] { });
object upperResult = typeof(Vector256<UInt32>)
- .GetMethod(nameof(Vector256<UInt32>.GetUpper), new Type[] { })
+ .GetMethod(nameof(Vector256.GetUpper), new Type[] { })
.Invoke(value, new object[] { });
ValidateGetResult((Vector128<UInt32>)(lowerResult), (Vector128<UInt32>)(upperResult), values);
object result = typeof(Vector256<UInt32>)
- .GetMethod(nameof(Vector256<UInt32>.WithLower), new Type[] { typeof(Vector128<UInt32>) })
+ .GetMethod(nameof(Vector256.WithLower), new Type[] { typeof(Vector128<UInt32>) })
.Invoke(value, new object[] { upperResult });
result = typeof(Vector256<UInt32>)
- .GetMethod(nameof(Vector256<UInt32>.WithUpper), new Type[] { typeof(Vector128<UInt32>) })
+ .GetMethod(nameof(Vector256.WithUpper), new Type[] { typeof(Vector128<UInt32>) })
.Invoke(result, new object[] { lowerResult });
ValidateWithResult((Vector256<UInt32>)(result), values);
}
Vector256<UInt64> value = Vector256.Create(values[0], values[1], values[2], values[3]);
object lowerResult = typeof(Vector256<UInt64>)
- .GetMethod(nameof(Vector256<UInt64>.GetLower), new Type[] { })
+ .GetMethod(nameof(Vector256.GetLower), new Type[] { })
.Invoke(value, new object[] { });
object upperResult = typeof(Vector256<UInt64>)
- .GetMethod(nameof(Vector256<UInt64>.GetUpper), new Type[] { })
+ .GetMethod(nameof(Vector256.GetUpper), new Type[] { })
.Invoke(value, new object[] { });
ValidateGetResult((Vector128<UInt64>)(lowerResult), (Vector128<UInt64>)(upperResult), values);
object result = typeof(Vector256<UInt64>)
- .GetMethod(nameof(Vector256<UInt64>.WithLower), new Type[] { typeof(Vector128<UInt64>) })
+ .GetMethod(nameof(Vector256.WithLower), new Type[] { typeof(Vector128<UInt64>) })
.Invoke(value, new object[] { upperResult });
result = typeof(Vector256<UInt64>)
- .GetMethod(nameof(Vector256<UInt64>.WithUpper), new Type[] { typeof(Vector128<UInt64>) })
+ .GetMethod(nameof(Vector256.WithUpper), new Type[] { typeof(Vector128<UInt64>) })
.Invoke(result, new object[] { lowerResult });
ValidateWithResult((Vector256<UInt64>)(result), values);
}
Vector256<Byte> value = Vector256.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31]);
object result = typeof(Vector256<Byte>)
- .GetMethod(nameof(Vector256<Byte>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector256.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Byte)(result), values);
Vector256<Double> value = Vector256.Create(values[0], values[1], values[2], values[3]);
object result = typeof(Vector256<Double>)
- .GetMethod(nameof(Vector256<Double>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector256.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Double)(result), values);
Vector256<Int16> value = Vector256.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]);
object result = typeof(Vector256<Int16>)
- .GetMethod(nameof(Vector256<Int16>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector256.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Int16)(result), values);
Vector256<Int32> value = Vector256.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]);
object result = typeof(Vector256<Int32>)
- .GetMethod(nameof(Vector256<Int32>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector256.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Int32)(result), values);
Vector256<Int64> value = Vector256.Create(values[0], values[1], values[2], values[3]);
object result = typeof(Vector256<Int64>)
- .GetMethod(nameof(Vector256<Int64>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector256.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Int64)(result), values);
Vector256<SByte> value = Vector256.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15], values[16], values[17], values[18], values[19], values[20], values[21], values[22], values[23], values[24], values[25], values[26], values[27], values[28], values[29], values[30], values[31]);
object result = typeof(Vector256<SByte>)
- .GetMethod(nameof(Vector256<SByte>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector256.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((SByte)(result), values);
Vector256<Single> value = Vector256.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]);
object result = typeof(Vector256<Single>)
- .GetMethod(nameof(Vector256<Single>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector256.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Single)(result), values);
Vector256<UInt16> value = Vector256.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8], values[9], values[10], values[11], values[12], values[13], values[14], values[15]);
object result = typeof(Vector256<UInt16>)
- .GetMethod(nameof(Vector256<UInt16>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector256.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((UInt16)(result), values);
Vector256<UInt32> value = Vector256.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]);
object result = typeof(Vector256<UInt32>)
- .GetMethod(nameof(Vector256<UInt32>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector256.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((UInt32)(result), values);
Vector256<UInt64> value = Vector256.Create(values[0], values[1], values[2], values[3]);
object result = typeof(Vector256<UInt64>)
- .GetMethod(nameof(Vector256<UInt64>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector256.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((UInt64)(result), values);
Vector64<Byte> value;
value = Vector64.Create(TestLibrary.Generator.GetByte());
- Vector64<byte> byteResult = value.As<byte>();
+ Vector64<byte> byteResult = value.As<Byte, byte>();
ValidateResult(byteResult, value);
value = Vector64.Create(TestLibrary.Generator.GetByte());
- Vector64<double> doubleResult = value.As<double>();
+ Vector64<double> doubleResult = value.As<Byte, double>();
ValidateResult(doubleResult, value);
value = Vector64.Create(TestLibrary.Generator.GetByte());
- Vector64<short> shortResult = value.As<short>();
+ Vector64<short> shortResult = value.As<Byte, short>();
ValidateResult(shortResult, value);
value = Vector64.Create(TestLibrary.Generator.GetByte());
- Vector64<int> intResult = value.As<int>();
+ Vector64<int> intResult = value.As<Byte, int>();
ValidateResult(intResult, value);
value = Vector64.Create(TestLibrary.Generator.GetByte());
- Vector64<long> longResult = value.As<long>();
+ Vector64<long> longResult = value.As<Byte, long>();
ValidateResult(longResult, value);
value = Vector64.Create(TestLibrary.Generator.GetByte());
- Vector64<sbyte> sbyteResult = value.As<sbyte>();
+ Vector64<sbyte> sbyteResult = value.As<Byte, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector64.Create(TestLibrary.Generator.GetByte());
- Vector64<float> floatResult = value.As<float>();
+ Vector64<float> floatResult = value.As<Byte, float>();
ValidateResult(floatResult, value);
value = Vector64.Create(TestLibrary.Generator.GetByte());
- Vector64<ushort> ushortResult = value.As<ushort>();
+ Vector64<ushort> ushortResult = value.As<Byte, ushort>();
ValidateResult(ushortResult, value);
value = Vector64.Create(TestLibrary.Generator.GetByte());
- Vector64<uint> uintResult = value.As<uint>();
+ Vector64<uint> uintResult = value.As<Byte, uint>();
ValidateResult(uintResult, value);
value = Vector64.Create(TestLibrary.Generator.GetByte());
- Vector64<ulong> ulongResult = value.As<ulong>();
+ Vector64<ulong> ulongResult = value.As<Byte, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector64.Create(TestLibrary.Generator.GetByte());
object byteResult = typeof(Vector64<Byte>)
- .GetMethod(nameof(Vector64<Byte>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector64.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<byte>)(byteResult), value);
value = Vector64.Create(TestLibrary.Generator.GetByte());
object doubleResult = typeof(Vector64<Byte>)
- .GetMethod(nameof(Vector64<Byte>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector64.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<double>)(doubleResult), value);
value = Vector64.Create(TestLibrary.Generator.GetByte());
object shortResult = typeof(Vector64<Byte>)
- .GetMethod(nameof(Vector64<Byte>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<short>)(shortResult), value);
value = Vector64.Create(TestLibrary.Generator.GetByte());
object intResult = typeof(Vector64<Byte>)
- .GetMethod(nameof(Vector64<Byte>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<int>)(intResult), value);
value = Vector64.Create(TestLibrary.Generator.GetByte());
object longResult = typeof(Vector64<Byte>)
- .GetMethod(nameof(Vector64<Byte>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<long>)(longResult), value);
value = Vector64.Create(TestLibrary.Generator.GetByte());
object sbyteResult = typeof(Vector64<Byte>)
- .GetMethod(nameof(Vector64<Byte>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector64.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<sbyte>)(sbyteResult), value);
value = Vector64.Create(TestLibrary.Generator.GetByte());
object floatResult = typeof(Vector64<Byte>)
- .GetMethod(nameof(Vector64<Byte>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector64.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<float>)(floatResult), value);
value = Vector64.Create(TestLibrary.Generator.GetByte());
object ushortResult = typeof(Vector64<Byte>)
- .GetMethod(nameof(Vector64<Byte>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<ushort>)(ushortResult), value);
value = Vector64.Create(TestLibrary.Generator.GetByte());
object uintResult = typeof(Vector64<Byte>)
- .GetMethod(nameof(Vector64<Byte>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<uint>)(uintResult), value);
value = Vector64.Create(TestLibrary.Generator.GetByte());
object ulongResult = typeof(Vector64<Byte>)
- .GetMethod(nameof(Vector64<Byte>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<ulong>)(ulongResult), value);
}
Vector64<Double> value;
value = Vector64.Create(TestLibrary.Generator.GetDouble());
- Vector64<byte> byteResult = value.As<byte>();
+ Vector64<byte> byteResult = value.As<Double, byte>();
ValidateResult(byteResult, value);
value = Vector64.Create(TestLibrary.Generator.GetDouble());
- Vector64<double> doubleResult = value.As<double>();
+ Vector64<double> doubleResult = value.As<Double, double>();
ValidateResult(doubleResult, value);
value = Vector64.Create(TestLibrary.Generator.GetDouble());
- Vector64<short> shortResult = value.As<short>();
+ Vector64<short> shortResult = value.As<Double, short>();
ValidateResult(shortResult, value);
value = Vector64.Create(TestLibrary.Generator.GetDouble());
- Vector64<int> intResult = value.As<int>();
+ Vector64<int> intResult = value.As<Double, int>();
ValidateResult(intResult, value);
value = Vector64.Create(TestLibrary.Generator.GetDouble());
- Vector64<long> longResult = value.As<long>();
+ Vector64<long> longResult = value.As<Double, long>();
ValidateResult(longResult, value);
value = Vector64.Create(TestLibrary.Generator.GetDouble());
- Vector64<sbyte> sbyteResult = value.As<sbyte>();
+ Vector64<sbyte> sbyteResult = value.As<Double, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector64.Create(TestLibrary.Generator.GetDouble());
- Vector64<float> floatResult = value.As<float>();
+ Vector64<float> floatResult = value.As<Double, float>();
ValidateResult(floatResult, value);
value = Vector64.Create(TestLibrary.Generator.GetDouble());
- Vector64<ushort> ushortResult = value.As<ushort>();
+ Vector64<ushort> ushortResult = value.As<Double, ushort>();
ValidateResult(ushortResult, value);
value = Vector64.Create(TestLibrary.Generator.GetDouble());
- Vector64<uint> uintResult = value.As<uint>();
+ Vector64<uint> uintResult = value.As<Double, uint>();
ValidateResult(uintResult, value);
value = Vector64.Create(TestLibrary.Generator.GetDouble());
- Vector64<ulong> ulongResult = value.As<ulong>();
+ Vector64<ulong> ulongResult = value.As<Double, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector64.Create(TestLibrary.Generator.GetDouble());
object byteResult = typeof(Vector64<Double>)
- .GetMethod(nameof(Vector64<Double>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector64.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<byte>)(byteResult), value);
value = Vector64.Create(TestLibrary.Generator.GetDouble());
object doubleResult = typeof(Vector64<Double>)
- .GetMethod(nameof(Vector64<Double>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector64.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<double>)(doubleResult), value);
value = Vector64.Create(TestLibrary.Generator.GetDouble());
object shortResult = typeof(Vector64<Double>)
- .GetMethod(nameof(Vector64<Double>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<short>)(shortResult), value);
value = Vector64.Create(TestLibrary.Generator.GetDouble());
object intResult = typeof(Vector64<Double>)
- .GetMethod(nameof(Vector64<Double>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<int>)(intResult), value);
value = Vector64.Create(TestLibrary.Generator.GetDouble());
object longResult = typeof(Vector64<Double>)
- .GetMethod(nameof(Vector64<Double>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<long>)(longResult), value);
value = Vector64.Create(TestLibrary.Generator.GetDouble());
object sbyteResult = typeof(Vector64<Double>)
- .GetMethod(nameof(Vector64<Double>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector64.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<sbyte>)(sbyteResult), value);
value = Vector64.Create(TestLibrary.Generator.GetDouble());
object floatResult = typeof(Vector64<Double>)
- .GetMethod(nameof(Vector64<Double>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector64.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<float>)(floatResult), value);
value = Vector64.Create(TestLibrary.Generator.GetDouble());
object ushortResult = typeof(Vector64<Double>)
- .GetMethod(nameof(Vector64<Double>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<ushort>)(ushortResult), value);
value = Vector64.Create(TestLibrary.Generator.GetDouble());
object uintResult = typeof(Vector64<Double>)
- .GetMethod(nameof(Vector64<Double>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<uint>)(uintResult), value);
value = Vector64.Create(TestLibrary.Generator.GetDouble());
object ulongResult = typeof(Vector64<Double>)
- .GetMethod(nameof(Vector64<Double>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<ulong>)(ulongResult), value);
}
Vector64<Int16> value;
value = Vector64.Create(TestLibrary.Generator.GetInt16());
- Vector64<byte> byteResult = value.As<byte>();
+ Vector64<byte> byteResult = value.As<Int16, byte>();
ValidateResult(byteResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt16());
- Vector64<double> doubleResult = value.As<double>();
+ Vector64<double> doubleResult = value.As<Int16, double>();
ValidateResult(doubleResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt16());
- Vector64<short> shortResult = value.As<short>();
+ Vector64<short> shortResult = value.As<Int16, short>();
ValidateResult(shortResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt16());
- Vector64<int> intResult = value.As<int>();
+ Vector64<int> intResult = value.As<Int16, int>();
ValidateResult(intResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt16());
- Vector64<long> longResult = value.As<long>();
+ Vector64<long> longResult = value.As<Int16, long>();
ValidateResult(longResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt16());
- Vector64<sbyte> sbyteResult = value.As<sbyte>();
+ Vector64<sbyte> sbyteResult = value.As<Int16, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt16());
- Vector64<float> floatResult = value.As<float>();
+ Vector64<float> floatResult = value.As<Int16, float>();
ValidateResult(floatResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt16());
- Vector64<ushort> ushortResult = value.As<ushort>();
+ Vector64<ushort> ushortResult = value.As<Int16, ushort>();
ValidateResult(ushortResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt16());
- Vector64<uint> uintResult = value.As<uint>();
+ Vector64<uint> uintResult = value.As<Int16, uint>();
ValidateResult(uintResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt16());
- Vector64<ulong> ulongResult = value.As<ulong>();
+ Vector64<ulong> ulongResult = value.As<Int16, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector64.Create(TestLibrary.Generator.GetInt16());
object byteResult = typeof(Vector64<Int16>)
- .GetMethod(nameof(Vector64<Int16>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector64.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<byte>)(byteResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt16());
object doubleResult = typeof(Vector64<Int16>)
- .GetMethod(nameof(Vector64<Int16>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector64.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<double>)(doubleResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt16());
object shortResult = typeof(Vector64<Int16>)
- .GetMethod(nameof(Vector64<Int16>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<short>)(shortResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt16());
object intResult = typeof(Vector64<Int16>)
- .GetMethod(nameof(Vector64<Int16>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<int>)(intResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt16());
object longResult = typeof(Vector64<Int16>)
- .GetMethod(nameof(Vector64<Int16>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<long>)(longResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt16());
object sbyteResult = typeof(Vector64<Int16>)
- .GetMethod(nameof(Vector64<Int16>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector64.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<sbyte>)(sbyteResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt16());
object floatResult = typeof(Vector64<Int16>)
- .GetMethod(nameof(Vector64<Int16>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector64.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<float>)(floatResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt16());
object ushortResult = typeof(Vector64<Int16>)
- .GetMethod(nameof(Vector64<Int16>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<ushort>)(ushortResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt16());
object uintResult = typeof(Vector64<Int16>)
- .GetMethod(nameof(Vector64<Int16>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<uint>)(uintResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt16());
object ulongResult = typeof(Vector64<Int16>)
- .GetMethod(nameof(Vector64<Int16>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<ulong>)(ulongResult), value);
}
Vector64<Int32> value;
value = Vector64.Create(TestLibrary.Generator.GetInt32());
- Vector64<byte> byteResult = value.As<byte>();
+ Vector64<byte> byteResult = value.As<Int32, byte>();
ValidateResult(byteResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt32());
- Vector64<double> doubleResult = value.As<double>();
+ Vector64<double> doubleResult = value.As<Int32, double>();
ValidateResult(doubleResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt32());
- Vector64<short> shortResult = value.As<short>();
+ Vector64<short> shortResult = value.As<Int32, short>();
ValidateResult(shortResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt32());
- Vector64<int> intResult = value.As<int>();
+ Vector64<int> intResult = value.As<Int32, int>();
ValidateResult(intResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt32());
- Vector64<long> longResult = value.As<long>();
+ Vector64<long> longResult = value.As<Int32, long>();
ValidateResult(longResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt32());
- Vector64<sbyte> sbyteResult = value.As<sbyte>();
+ Vector64<sbyte> sbyteResult = value.As<Int32, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt32());
- Vector64<float> floatResult = value.As<float>();
+ Vector64<float> floatResult = value.As<Int32, float>();
ValidateResult(floatResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt32());
- Vector64<ushort> ushortResult = value.As<ushort>();
+ Vector64<ushort> ushortResult = value.As<Int32, ushort>();
ValidateResult(ushortResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt32());
- Vector64<uint> uintResult = value.As<uint>();
+ Vector64<uint> uintResult = value.As<Int32, uint>();
ValidateResult(uintResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt32());
- Vector64<ulong> ulongResult = value.As<ulong>();
+ Vector64<ulong> ulongResult = value.As<Int32, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector64.Create(TestLibrary.Generator.GetInt32());
object byteResult = typeof(Vector64<Int32>)
- .GetMethod(nameof(Vector64<Int32>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector64.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<byte>)(byteResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt32());
object doubleResult = typeof(Vector64<Int32>)
- .GetMethod(nameof(Vector64<Int32>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector64.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<double>)(doubleResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt32());
object shortResult = typeof(Vector64<Int32>)
- .GetMethod(nameof(Vector64<Int32>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<short>)(shortResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt32());
object intResult = typeof(Vector64<Int32>)
- .GetMethod(nameof(Vector64<Int32>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<int>)(intResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt32());
object longResult = typeof(Vector64<Int32>)
- .GetMethod(nameof(Vector64<Int32>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<long>)(longResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt32());
object sbyteResult = typeof(Vector64<Int32>)
- .GetMethod(nameof(Vector64<Int32>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector64.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<sbyte>)(sbyteResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt32());
object floatResult = typeof(Vector64<Int32>)
- .GetMethod(nameof(Vector64<Int32>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector64.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<float>)(floatResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt32());
object ushortResult = typeof(Vector64<Int32>)
- .GetMethod(nameof(Vector64<Int32>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<ushort>)(ushortResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt32());
object uintResult = typeof(Vector64<Int32>)
- .GetMethod(nameof(Vector64<Int32>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<uint>)(uintResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt32());
object ulongResult = typeof(Vector64<Int32>)
- .GetMethod(nameof(Vector64<Int32>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<ulong>)(ulongResult), value);
}
Vector64<Int64> value;
value = Vector64.Create(TestLibrary.Generator.GetInt64());
- Vector64<byte> byteResult = value.As<byte>();
+ Vector64<byte> byteResult = value.As<Int64, byte>();
ValidateResult(byteResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt64());
- Vector64<double> doubleResult = value.As<double>();
+ Vector64<double> doubleResult = value.As<Int64, double>();
ValidateResult(doubleResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt64());
- Vector64<short> shortResult = value.As<short>();
+ Vector64<short> shortResult = value.As<Int64, short>();
ValidateResult(shortResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt64());
- Vector64<int> intResult = value.As<int>();
+ Vector64<int> intResult = value.As<Int64, int>();
ValidateResult(intResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt64());
- Vector64<long> longResult = value.As<long>();
+ Vector64<long> longResult = value.As<Int64, long>();
ValidateResult(longResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt64());
- Vector64<sbyte> sbyteResult = value.As<sbyte>();
+ Vector64<sbyte> sbyteResult = value.As<Int64, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt64());
- Vector64<float> floatResult = value.As<float>();
+ Vector64<float> floatResult = value.As<Int64, float>();
ValidateResult(floatResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt64());
- Vector64<ushort> ushortResult = value.As<ushort>();
+ Vector64<ushort> ushortResult = value.As<Int64, ushort>();
ValidateResult(ushortResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt64());
- Vector64<uint> uintResult = value.As<uint>();
+ Vector64<uint> uintResult = value.As<Int64, uint>();
ValidateResult(uintResult, value);
value = Vector64.Create(TestLibrary.Generator.GetInt64());
- Vector64<ulong> ulongResult = value.As<ulong>();
+ Vector64<ulong> ulongResult = value.As<Int64, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector64.Create(TestLibrary.Generator.GetInt64());
object byteResult = typeof(Vector64<Int64>)
- .GetMethod(nameof(Vector64<Int64>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector64.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<byte>)(byteResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt64());
object doubleResult = typeof(Vector64<Int64>)
- .GetMethod(nameof(Vector64<Int64>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector64.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<double>)(doubleResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt64());
object shortResult = typeof(Vector64<Int64>)
- .GetMethod(nameof(Vector64<Int64>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<short>)(shortResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt64());
object intResult = typeof(Vector64<Int64>)
- .GetMethod(nameof(Vector64<Int64>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<int>)(intResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt64());
object longResult = typeof(Vector64<Int64>)
- .GetMethod(nameof(Vector64<Int64>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<long>)(longResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt64());
object sbyteResult = typeof(Vector64<Int64>)
- .GetMethod(nameof(Vector64<Int64>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector64.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<sbyte>)(sbyteResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt64());
object floatResult = typeof(Vector64<Int64>)
- .GetMethod(nameof(Vector64<Int64>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector64.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<float>)(floatResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt64());
object ushortResult = typeof(Vector64<Int64>)
- .GetMethod(nameof(Vector64<Int64>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<ushort>)(ushortResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt64());
object uintResult = typeof(Vector64<Int64>)
- .GetMethod(nameof(Vector64<Int64>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<uint>)(uintResult), value);
value = Vector64.Create(TestLibrary.Generator.GetInt64());
object ulongResult = typeof(Vector64<Int64>)
- .GetMethod(nameof(Vector64<Int64>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<ulong>)(ulongResult), value);
}
Vector64<SByte> value;
value = Vector64.Create(TestLibrary.Generator.GetSByte());
- Vector64<byte> byteResult = value.As<byte>();
+ Vector64<byte> byteResult = value.As<SByte, byte>();
ValidateResult(byteResult, value);
value = Vector64.Create(TestLibrary.Generator.GetSByte());
- Vector64<double> doubleResult = value.As<double>();
+ Vector64<double> doubleResult = value.As<SByte, double>();
ValidateResult(doubleResult, value);
value = Vector64.Create(TestLibrary.Generator.GetSByte());
- Vector64<short> shortResult = value.As<short>();
+ Vector64<short> shortResult = value.As<SByte, short>();
ValidateResult(shortResult, value);
value = Vector64.Create(TestLibrary.Generator.GetSByte());
- Vector64<int> intResult = value.As<int>();
+ Vector64<int> intResult = value.As<SByte, int>();
ValidateResult(intResult, value);
value = Vector64.Create(TestLibrary.Generator.GetSByte());
- Vector64<long> longResult = value.As<long>();
+ Vector64<long> longResult = value.As<SByte, long>();
ValidateResult(longResult, value);
value = Vector64.Create(TestLibrary.Generator.GetSByte());
- Vector64<sbyte> sbyteResult = value.As<sbyte>();
+ Vector64<sbyte> sbyteResult = value.As<SByte, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector64.Create(TestLibrary.Generator.GetSByte());
- Vector64<float> floatResult = value.As<float>();
+ Vector64<float> floatResult = value.As<SByte, float>();
ValidateResult(floatResult, value);
value = Vector64.Create(TestLibrary.Generator.GetSByte());
- Vector64<ushort> ushortResult = value.As<ushort>();
+ Vector64<ushort> ushortResult = value.As<SByte, ushort>();
ValidateResult(ushortResult, value);
value = Vector64.Create(TestLibrary.Generator.GetSByte());
- Vector64<uint> uintResult = value.As<uint>();
+ Vector64<uint> uintResult = value.As<SByte, uint>();
ValidateResult(uintResult, value);
value = Vector64.Create(TestLibrary.Generator.GetSByte());
- Vector64<ulong> ulongResult = value.As<ulong>();
+ Vector64<ulong> ulongResult = value.As<SByte, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector64.Create(TestLibrary.Generator.GetSByte());
object byteResult = typeof(Vector64<SByte>)
- .GetMethod(nameof(Vector64<SByte>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector64.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<byte>)(byteResult), value);
value = Vector64.Create(TestLibrary.Generator.GetSByte());
object doubleResult = typeof(Vector64<SByte>)
- .GetMethod(nameof(Vector64<SByte>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector64.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<double>)(doubleResult), value);
value = Vector64.Create(TestLibrary.Generator.GetSByte());
object shortResult = typeof(Vector64<SByte>)
- .GetMethod(nameof(Vector64<SByte>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<short>)(shortResult), value);
value = Vector64.Create(TestLibrary.Generator.GetSByte());
object intResult = typeof(Vector64<SByte>)
- .GetMethod(nameof(Vector64<SByte>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<int>)(intResult), value);
value = Vector64.Create(TestLibrary.Generator.GetSByte());
object longResult = typeof(Vector64<SByte>)
- .GetMethod(nameof(Vector64<SByte>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<long>)(longResult), value);
value = Vector64.Create(TestLibrary.Generator.GetSByte());
object sbyteResult = typeof(Vector64<SByte>)
- .GetMethod(nameof(Vector64<SByte>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector64.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<sbyte>)(sbyteResult), value);
value = Vector64.Create(TestLibrary.Generator.GetSByte());
object floatResult = typeof(Vector64<SByte>)
- .GetMethod(nameof(Vector64<SByte>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector64.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<float>)(floatResult), value);
value = Vector64.Create(TestLibrary.Generator.GetSByte());
object ushortResult = typeof(Vector64<SByte>)
- .GetMethod(nameof(Vector64<SByte>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<ushort>)(ushortResult), value);
value = Vector64.Create(TestLibrary.Generator.GetSByte());
object uintResult = typeof(Vector64<SByte>)
- .GetMethod(nameof(Vector64<SByte>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<uint>)(uintResult), value);
value = Vector64.Create(TestLibrary.Generator.GetSByte());
object ulongResult = typeof(Vector64<SByte>)
- .GetMethod(nameof(Vector64<SByte>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<ulong>)(ulongResult), value);
}
Vector64<Single> value;
value = Vector64.Create(TestLibrary.Generator.GetSingle());
- Vector64<byte> byteResult = value.As<byte>();
+ Vector64<byte> byteResult = value.As<Single, byte>();
ValidateResult(byteResult, value);
value = Vector64.Create(TestLibrary.Generator.GetSingle());
- Vector64<double> doubleResult = value.As<double>();
+ Vector64<double> doubleResult = value.As<Single, double>();
ValidateResult(doubleResult, value);
value = Vector64.Create(TestLibrary.Generator.GetSingle());
- Vector64<short> shortResult = value.As<short>();
+ Vector64<short> shortResult = value.As<Single, short>();
ValidateResult(shortResult, value);
value = Vector64.Create(TestLibrary.Generator.GetSingle());
- Vector64<int> intResult = value.As<int>();
+ Vector64<int> intResult = value.As<Single, int>();
ValidateResult(intResult, value);
value = Vector64.Create(TestLibrary.Generator.GetSingle());
- Vector64<long> longResult = value.As<long>();
+ Vector64<long> longResult = value.As<Single, long>();
ValidateResult(longResult, value);
value = Vector64.Create(TestLibrary.Generator.GetSingle());
- Vector64<sbyte> sbyteResult = value.As<sbyte>();
+ Vector64<sbyte> sbyteResult = value.As<Single, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector64.Create(TestLibrary.Generator.GetSingle());
- Vector64<float> floatResult = value.As<float>();
+ Vector64<float> floatResult = value.As<Single, float>();
ValidateResult(floatResult, value);
value = Vector64.Create(TestLibrary.Generator.GetSingle());
- Vector64<ushort> ushortResult = value.As<ushort>();
+ Vector64<ushort> ushortResult = value.As<Single, ushort>();
ValidateResult(ushortResult, value);
value = Vector64.Create(TestLibrary.Generator.GetSingle());
- Vector64<uint> uintResult = value.As<uint>();
+ Vector64<uint> uintResult = value.As<Single, uint>();
ValidateResult(uintResult, value);
value = Vector64.Create(TestLibrary.Generator.GetSingle());
- Vector64<ulong> ulongResult = value.As<ulong>();
+ Vector64<ulong> ulongResult = value.As<Single, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector64.Create(TestLibrary.Generator.GetSingle());
object byteResult = typeof(Vector64<Single>)
- .GetMethod(nameof(Vector64<Single>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector64.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<byte>)(byteResult), value);
value = Vector64.Create(TestLibrary.Generator.GetSingle());
object doubleResult = typeof(Vector64<Single>)
- .GetMethod(nameof(Vector64<Single>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector64.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<double>)(doubleResult), value);
value = Vector64.Create(TestLibrary.Generator.GetSingle());
object shortResult = typeof(Vector64<Single>)
- .GetMethod(nameof(Vector64<Single>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<short>)(shortResult), value);
value = Vector64.Create(TestLibrary.Generator.GetSingle());
object intResult = typeof(Vector64<Single>)
- .GetMethod(nameof(Vector64<Single>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<int>)(intResult), value);
value = Vector64.Create(TestLibrary.Generator.GetSingle());
object longResult = typeof(Vector64<Single>)
- .GetMethod(nameof(Vector64<Single>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<long>)(longResult), value);
value = Vector64.Create(TestLibrary.Generator.GetSingle());
object sbyteResult = typeof(Vector64<Single>)
- .GetMethod(nameof(Vector64<Single>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector64.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<sbyte>)(sbyteResult), value);
value = Vector64.Create(TestLibrary.Generator.GetSingle());
object floatResult = typeof(Vector64<Single>)
- .GetMethod(nameof(Vector64<Single>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector64.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<float>)(floatResult), value);
value = Vector64.Create(TestLibrary.Generator.GetSingle());
object ushortResult = typeof(Vector64<Single>)
- .GetMethod(nameof(Vector64<Single>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<ushort>)(ushortResult), value);
value = Vector64.Create(TestLibrary.Generator.GetSingle());
object uintResult = typeof(Vector64<Single>)
- .GetMethod(nameof(Vector64<Single>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<uint>)(uintResult), value);
value = Vector64.Create(TestLibrary.Generator.GetSingle());
object ulongResult = typeof(Vector64<Single>)
- .GetMethod(nameof(Vector64<Single>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<ulong>)(ulongResult), value);
}
Vector64<UInt16> value;
value = Vector64.Create(TestLibrary.Generator.GetUInt16());
- Vector64<byte> byteResult = value.As<byte>();
+ Vector64<byte> byteResult = value.As<UInt16, byte>();
ValidateResult(byteResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt16());
- Vector64<double> doubleResult = value.As<double>();
+ Vector64<double> doubleResult = value.As<UInt16, double>();
ValidateResult(doubleResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt16());
- Vector64<short> shortResult = value.As<short>();
+ Vector64<short> shortResult = value.As<UInt16, short>();
ValidateResult(shortResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt16());
- Vector64<int> intResult = value.As<int>();
+ Vector64<int> intResult = value.As<UInt16, int>();
ValidateResult(intResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt16());
- Vector64<long> longResult = value.As<long>();
+ Vector64<long> longResult = value.As<UInt16, long>();
ValidateResult(longResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt16());
- Vector64<sbyte> sbyteResult = value.As<sbyte>();
+ Vector64<sbyte> sbyteResult = value.As<UInt16, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt16());
- Vector64<float> floatResult = value.As<float>();
+ Vector64<float> floatResult = value.As<UInt16, float>();
ValidateResult(floatResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt16());
- Vector64<ushort> ushortResult = value.As<ushort>();
+ Vector64<ushort> ushortResult = value.As<UInt16, ushort>();
ValidateResult(ushortResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt16());
- Vector64<uint> uintResult = value.As<uint>();
+ Vector64<uint> uintResult = value.As<UInt16, uint>();
ValidateResult(uintResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt16());
- Vector64<ulong> ulongResult = value.As<ulong>();
+ Vector64<ulong> ulongResult = value.As<UInt16, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector64.Create(TestLibrary.Generator.GetUInt16());
object byteResult = typeof(Vector64<UInt16>)
- .GetMethod(nameof(Vector64<UInt16>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector64.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<byte>)(byteResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt16());
object doubleResult = typeof(Vector64<UInt16>)
- .GetMethod(nameof(Vector64<UInt16>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector64.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<double>)(doubleResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt16());
object shortResult = typeof(Vector64<UInt16>)
- .GetMethod(nameof(Vector64<UInt16>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<short>)(shortResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt16());
object intResult = typeof(Vector64<UInt16>)
- .GetMethod(nameof(Vector64<UInt16>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<int>)(intResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt16());
object longResult = typeof(Vector64<UInt16>)
- .GetMethod(nameof(Vector64<UInt16>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<long>)(longResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt16());
object sbyteResult = typeof(Vector64<UInt16>)
- .GetMethod(nameof(Vector64<UInt16>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector64.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<sbyte>)(sbyteResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt16());
object floatResult = typeof(Vector64<UInt16>)
- .GetMethod(nameof(Vector64<UInt16>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector64.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<float>)(floatResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt16());
object ushortResult = typeof(Vector64<UInt16>)
- .GetMethod(nameof(Vector64<UInt16>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<ushort>)(ushortResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt16());
object uintResult = typeof(Vector64<UInt16>)
- .GetMethod(nameof(Vector64<UInt16>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<uint>)(uintResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt16());
object ulongResult = typeof(Vector64<UInt16>)
- .GetMethod(nameof(Vector64<UInt16>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<ulong>)(ulongResult), value);
}
Vector64<UInt32> value;
value = Vector64.Create(TestLibrary.Generator.GetUInt32());
- Vector64<byte> byteResult = value.As<byte>();
+ Vector64<byte> byteResult = value.As<UInt32, byte>();
ValidateResult(byteResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt32());
- Vector64<double> doubleResult = value.As<double>();
+ Vector64<double> doubleResult = value.As<UInt32, double>();
ValidateResult(doubleResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt32());
- Vector64<short> shortResult = value.As<short>();
+ Vector64<short> shortResult = value.As<UInt32, short>();
ValidateResult(shortResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt32());
- Vector64<int> intResult = value.As<int>();
+ Vector64<int> intResult = value.As<UInt32, int>();
ValidateResult(intResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt32());
- Vector64<long> longResult = value.As<long>();
+ Vector64<long> longResult = value.As<UInt32, long>();
ValidateResult(longResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt32());
- Vector64<sbyte> sbyteResult = value.As<sbyte>();
+ Vector64<sbyte> sbyteResult = value.As<UInt32, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt32());
- Vector64<float> floatResult = value.As<float>();
+ Vector64<float> floatResult = value.As<UInt32, float>();
ValidateResult(floatResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt32());
- Vector64<ushort> ushortResult = value.As<ushort>();
+ Vector64<ushort> ushortResult = value.As<UInt32, ushort>();
ValidateResult(ushortResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt32());
- Vector64<uint> uintResult = value.As<uint>();
+ Vector64<uint> uintResult = value.As<UInt32, uint>();
ValidateResult(uintResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt32());
- Vector64<ulong> ulongResult = value.As<ulong>();
+ Vector64<ulong> ulongResult = value.As<UInt32, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector64.Create(TestLibrary.Generator.GetUInt32());
object byteResult = typeof(Vector64<UInt32>)
- .GetMethod(nameof(Vector64<UInt32>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector64.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<byte>)(byteResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt32());
object doubleResult = typeof(Vector64<UInt32>)
- .GetMethod(nameof(Vector64<UInt32>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector64.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<double>)(doubleResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt32());
object shortResult = typeof(Vector64<UInt32>)
- .GetMethod(nameof(Vector64<UInt32>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<short>)(shortResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt32());
object intResult = typeof(Vector64<UInt32>)
- .GetMethod(nameof(Vector64<UInt32>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<int>)(intResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt32());
object longResult = typeof(Vector64<UInt32>)
- .GetMethod(nameof(Vector64<UInt32>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<long>)(longResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt32());
object sbyteResult = typeof(Vector64<UInt32>)
- .GetMethod(nameof(Vector64<UInt32>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector64.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<sbyte>)(sbyteResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt32());
object floatResult = typeof(Vector64<UInt32>)
- .GetMethod(nameof(Vector64<UInt32>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector64.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<float>)(floatResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt32());
object ushortResult = typeof(Vector64<UInt32>)
- .GetMethod(nameof(Vector64<UInt32>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<ushort>)(ushortResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt32());
object uintResult = typeof(Vector64<UInt32>)
- .GetMethod(nameof(Vector64<UInt32>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<uint>)(uintResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt32());
object ulongResult = typeof(Vector64<UInt32>)
- .GetMethod(nameof(Vector64<UInt32>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<ulong>)(ulongResult), value);
}
Vector64<UInt64> value;
value = Vector64.Create(TestLibrary.Generator.GetUInt64());
- Vector64<byte> byteResult = value.As<byte>();
+ Vector64<byte> byteResult = value.As<UInt64, byte>();
ValidateResult(byteResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt64());
- Vector64<double> doubleResult = value.As<double>();
+ Vector64<double> doubleResult = value.As<UInt64, double>();
ValidateResult(doubleResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt64());
- Vector64<short> shortResult = value.As<short>();
+ Vector64<short> shortResult = value.As<UInt64, short>();
ValidateResult(shortResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt64());
- Vector64<int> intResult = value.As<int>();
+ Vector64<int> intResult = value.As<UInt64, int>();
ValidateResult(intResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt64());
- Vector64<long> longResult = value.As<long>();
+ Vector64<long> longResult = value.As<UInt64, long>();
ValidateResult(longResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt64());
- Vector64<sbyte> sbyteResult = value.As<sbyte>();
+ Vector64<sbyte> sbyteResult = value.As<UInt64, sbyte>();
ValidateResult(sbyteResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt64());
- Vector64<float> floatResult = value.As<float>();
+ Vector64<float> floatResult = value.As<UInt64, float>();
ValidateResult(floatResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt64());
- Vector64<ushort> ushortResult = value.As<ushort>();
+ Vector64<ushort> ushortResult = value.As<UInt64, ushort>();
ValidateResult(ushortResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt64());
- Vector64<uint> uintResult = value.As<uint>();
+ Vector64<uint> uintResult = value.As<UInt64, uint>();
ValidateResult(uintResult, value);
value = Vector64.Create(TestLibrary.Generator.GetUInt64());
- Vector64<ulong> ulongResult = value.As<ulong>();
+ Vector64<ulong> ulongResult = value.As<UInt64, ulong>();
ValidateResult(ulongResult, value);
}
value = Vector64.Create(TestLibrary.Generator.GetUInt64());
object byteResult = typeof(Vector64<UInt64>)
- .GetMethod(nameof(Vector64<UInt64>.AsByte), new Type[] { })
+ .GetMethod(nameof(Vector64.AsByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<byte>)(byteResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt64());
object doubleResult = typeof(Vector64<UInt64>)
- .GetMethod(nameof(Vector64<UInt64>.AsDouble), new Type[] { })
+ .GetMethod(nameof(Vector64.AsDouble), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<double>)(doubleResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt64());
object shortResult = typeof(Vector64<UInt64>)
- .GetMethod(nameof(Vector64<UInt64>.AsInt16), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<short>)(shortResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt64());
object intResult = typeof(Vector64<UInt64>)
- .GetMethod(nameof(Vector64<UInt64>.AsInt32), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<int>)(intResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt64());
object longResult = typeof(Vector64<UInt64>)
- .GetMethod(nameof(Vector64<UInt64>.AsInt64), new Type[] { })
+ .GetMethod(nameof(Vector64.AsInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<long>)(longResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt64());
object sbyteResult = typeof(Vector64<UInt64>)
- .GetMethod(nameof(Vector64<UInt64>.AsSByte), new Type[] { })
+ .GetMethod(nameof(Vector64.AsSByte), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<sbyte>)(sbyteResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt64());
object floatResult = typeof(Vector64<UInt64>)
- .GetMethod(nameof(Vector64<UInt64>.AsSingle), new Type[] { })
+ .GetMethod(nameof(Vector64.AsSingle), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<float>)(floatResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt64());
object ushortResult = typeof(Vector64<UInt64>)
- .GetMethod(nameof(Vector64<UInt64>.AsUInt16), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt16), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<ushort>)(ushortResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt64());
object uintResult = typeof(Vector64<UInt64>)
- .GetMethod(nameof(Vector64<UInt64>.AsUInt32), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt32), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<uint>)(uintResult), value);
value = Vector64.Create(TestLibrary.Generator.GetUInt64());
object ulongResult = typeof(Vector64<UInt64>)
- .GetMethod(nameof(Vector64<UInt64>.AsUInt64), new Type[] { })
+ .GetMethod(nameof(Vector64.AsUInt64), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector64<ulong>)(ulongResult), value);
}
try
{
object result = typeof(Vector64<Byte>)
- .GetMethod(nameof(Vector64<Byte>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector64.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Byte)(result), values);
}
try
{
object result2 = typeof(Vector64<Byte>)
- .GetMethod(nameof(Vector64<Byte>.WithElement), new Type[] { typeof(int), typeof(Byte) })
+ .GetMethod(nameof(Vector64.WithElement), new Type[] { typeof(int), typeof(Byte) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector64<Byte>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector64<Byte>)
- .GetMethod(nameof(Vector64<Byte>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector64.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Byte)(result), values);
}
try
{
object result2 = typeof(Vector64<Byte>)
- .GetMethod(nameof(Vector64<Byte>.WithElement), new Type[] { typeof(int), typeof(Byte) })
+ .GetMethod(nameof(Vector64.WithElement), new Type[] { typeof(int), typeof(Byte) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector64<Byte>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector64<Double>)
- .GetMethod(nameof(Vector64<Double>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector64.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Double)(result), values);
}
try
{
object result2 = typeof(Vector64<Double>)
- .GetMethod(nameof(Vector64<Double>.WithElement), new Type[] { typeof(int), typeof(Double) })
+ .GetMethod(nameof(Vector64.WithElement), new Type[] { typeof(int), typeof(Double) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector64<Double>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector64<Int16>)
- .GetMethod(nameof(Vector64<Int16>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector64.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int16)(result), values);
}
try
{
object result2 = typeof(Vector64<Int16>)
- .GetMethod(nameof(Vector64<Int16>.WithElement), new Type[] { typeof(int), typeof(Int16) })
+ .GetMethod(nameof(Vector64.WithElement), new Type[] { typeof(int), typeof(Int16) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector64<Int16>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector64<Int16>)
- .GetMethod(nameof(Vector64<Int16>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector64.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int16)(result), values);
}
try
{
object result2 = typeof(Vector64<Int16>)
- .GetMethod(nameof(Vector64<Int16>.WithElement), new Type[] { typeof(int), typeof(Int16) })
+ .GetMethod(nameof(Vector64.WithElement), new Type[] { typeof(int), typeof(Int16) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector64<Int16>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector64<Int32>)
- .GetMethod(nameof(Vector64<Int32>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector64.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int32)(result), values);
}
try
{
object result2 = typeof(Vector64<Int32>)
- .GetMethod(nameof(Vector64<Int32>.WithElement), new Type[] { typeof(int), typeof(Int32) })
+ .GetMethod(nameof(Vector64.WithElement), new Type[] { typeof(int), typeof(Int32) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector64<Int32>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector64<Int32>)
- .GetMethod(nameof(Vector64<Int32>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector64.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int32)(result), values);
}
try
{
object result2 = typeof(Vector64<Int32>)
- .GetMethod(nameof(Vector64<Int32>.WithElement), new Type[] { typeof(int), typeof(Int32) })
+ .GetMethod(nameof(Vector64.WithElement), new Type[] { typeof(int), typeof(Int32) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector64<Int32>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector64<Int64>)
- .GetMethod(nameof(Vector64<Int64>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector64.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Int64)(result), values);
}
try
{
object result2 = typeof(Vector64<Int64>)
- .GetMethod(nameof(Vector64<Int64>.WithElement), new Type[] { typeof(int), typeof(Int64) })
+ .GetMethod(nameof(Vector64.WithElement), new Type[] { typeof(int), typeof(Int64) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector64<Int64>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector64<SByte>)
- .GetMethod(nameof(Vector64<SByte>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector64.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((SByte)(result), values);
}
try
{
object result2 = typeof(Vector64<SByte>)
- .GetMethod(nameof(Vector64<SByte>.WithElement), new Type[] { typeof(int), typeof(SByte) })
+ .GetMethod(nameof(Vector64.WithElement), new Type[] { typeof(int), typeof(SByte) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector64<SByte>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector64<SByte>)
- .GetMethod(nameof(Vector64<SByte>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector64.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((SByte)(result), values);
}
try
{
object result2 = typeof(Vector64<SByte>)
- .GetMethod(nameof(Vector64<SByte>.WithElement), new Type[] { typeof(int), typeof(SByte) })
+ .GetMethod(nameof(Vector64.WithElement), new Type[] { typeof(int), typeof(SByte) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector64<SByte>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector64<Single>)
- .GetMethod(nameof(Vector64<Single>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector64.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Single)(result), values);
}
try
{
object result2 = typeof(Vector64<Single>)
- .GetMethod(nameof(Vector64<Single>.WithElement), new Type[] { typeof(int), typeof(Single) })
+ .GetMethod(nameof(Vector64.WithElement), new Type[] { typeof(int), typeof(Single) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector64<Single>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector64<Single>)
- .GetMethod(nameof(Vector64<Single>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector64.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((Single)(result), values);
}
try
{
object result2 = typeof(Vector64<Single>)
- .GetMethod(nameof(Vector64<Single>.WithElement), new Type[] { typeof(int), typeof(Single) })
+ .GetMethod(nameof(Vector64.WithElement), new Type[] { typeof(int), typeof(Single) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector64<Single>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector64<UInt16>)
- .GetMethod(nameof(Vector64<UInt16>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector64.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt16)(result), values);
}
try
{
object result2 = typeof(Vector64<UInt16>)
- .GetMethod(nameof(Vector64<UInt16>.WithElement), new Type[] { typeof(int), typeof(UInt16) })
+ .GetMethod(nameof(Vector64.WithElement), new Type[] { typeof(int), typeof(UInt16) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector64<UInt16>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector64<UInt16>)
- .GetMethod(nameof(Vector64<UInt16>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector64.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt16)(result), values);
}
try
{
object result2 = typeof(Vector64<UInt16>)
- .GetMethod(nameof(Vector64<UInt16>.WithElement), new Type[] { typeof(int), typeof(UInt16) })
+ .GetMethod(nameof(Vector64.WithElement), new Type[] { typeof(int), typeof(UInt16) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector64<UInt16>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector64<UInt32>)
- .GetMethod(nameof(Vector64<UInt32>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector64.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt32)(result), values);
}
try
{
object result2 = typeof(Vector64<UInt32>)
- .GetMethod(nameof(Vector64<UInt32>.WithElement), new Type[] { typeof(int), typeof(UInt32) })
+ .GetMethod(nameof(Vector64.WithElement), new Type[] { typeof(int), typeof(UInt32) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector64<UInt32>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector64<UInt32>)
- .GetMethod(nameof(Vector64<UInt32>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector64.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt32)(result), values);
}
try
{
object result2 = typeof(Vector64<UInt32>)
- .GetMethod(nameof(Vector64<UInt32>.WithElement), new Type[] { typeof(int), typeof(UInt32) })
+ .GetMethod(nameof(Vector64.WithElement), new Type[] { typeof(int), typeof(UInt32) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector64<UInt32>)(result2), values, insertedValue);
}
try
{
object result = typeof(Vector64<UInt64>)
- .GetMethod(nameof(Vector64<UInt64>.GetElement), new Type[] { typeof(int) })
+ .GetMethod(nameof(Vector64.GetElement), new Type[] { typeof(int) })
.Invoke(value, new object[] { imm });
ValidateGetResult((UInt64)(result), values);
}
try
{
object result2 = typeof(Vector64<UInt64>)
- .GetMethod(nameof(Vector64<UInt64>.WithElement), new Type[] { typeof(int), typeof(UInt64) })
+ .GetMethod(nameof(Vector64.WithElement), new Type[] { typeof(int), typeof(UInt64) })
.Invoke(value, new object[] { imm, insertedValue });
ValidateWithResult((Vector64<UInt64>)(result2), values, insertedValue);
}
Vector64<Byte> value = Vector64.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]);
object result = typeof(Vector64<Byte>)
- .GetMethod(nameof(Vector64<Byte>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector64.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Byte)(result), values);
Vector64<Double> value = Vector64.Create(values[0]);
object result = typeof(Vector64<Double>)
- .GetMethod(nameof(Vector64<Double>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector64.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Double)(result), values);
Vector64<Int16> value = Vector64.Create(values[0], values[1], values[2], values[3]);
object result = typeof(Vector64<Int16>)
- .GetMethod(nameof(Vector64<Int16>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector64.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Int16)(result), values);
Vector64<Int32> value = Vector64.Create(values[0], values[1]);
object result = typeof(Vector64<Int32>)
- .GetMethod(nameof(Vector64<Int32>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector64.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Int32)(result), values);
Vector64<Int64> value = Vector64.Create(values[0]);
object result = typeof(Vector64<Int64>)
- .GetMethod(nameof(Vector64<Int64>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector64.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Int64)(result), values);
Vector64<SByte> value = Vector64.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]);
object result = typeof(Vector64<SByte>)
- .GetMethod(nameof(Vector64<SByte>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector64.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((SByte)(result), values);
Vector64<Single> value = Vector64.Create(values[0], values[1]);
object result = typeof(Vector64<Single>)
- .GetMethod(nameof(Vector64<Single>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector64.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Single)(result), values);
Vector64<UInt16> value = Vector64.Create(values[0], values[1], values[2], values[3]);
object result = typeof(Vector64<UInt16>)
- .GetMethod(nameof(Vector64<UInt16>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector64.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((UInt16)(result), values);
Vector64<UInt32> value = Vector64.Create(values[0], values[1]);
object result = typeof(Vector64<UInt32>)
- .GetMethod(nameof(Vector64<UInt32>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector64.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((UInt32)(result), values);
Vector64<UInt64> value = Vector64.Create(values[0]);
object result = typeof(Vector64<UInt64>)
- .GetMethod(nameof(Vector64<UInt64>.ToScalar), new Type[] { })
+ .GetMethod(nameof(Vector64.ToScalar), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((UInt64)(result), values);
Vector64<Byte> value = Vector64.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]);
object result = typeof(Vector64<Byte>)
- .GetMethod(nameof(Vector64<Byte>.ToVector128), new Type[] { })
+ .GetMethod(nameof(Vector64.ToVector128), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<Byte>)(result), values, isUnsafe: false);
object unsafeResult = typeof(Vector64<Byte>)
- .GetMethod(nameof(Vector64<Byte>.ToVector128), new Type[] { })
+ .GetMethod(nameof(Vector64.ToVector128), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<Byte>)(unsafeResult), values, isUnsafe: true);
}
Vector64<Double> value = Vector64.Create(values[0]);
object result = typeof(Vector64<Double>)
- .GetMethod(nameof(Vector64<Double>.ToVector128), new Type[] { })
+ .GetMethod(nameof(Vector64.ToVector128), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<Double>)(result), values, isUnsafe: false);
object unsafeResult = typeof(Vector64<Double>)
- .GetMethod(nameof(Vector64<Double>.ToVector128), new Type[] { })
+ .GetMethod(nameof(Vector64.ToVector128), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<Double>)(unsafeResult), values, isUnsafe: true);
}
Vector64<Int16> value = Vector64.Create(values[0], values[1], values[2], values[3]);
object result = typeof(Vector64<Int16>)
- .GetMethod(nameof(Vector64<Int16>.ToVector128), new Type[] { })
+ .GetMethod(nameof(Vector64.ToVector128), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<Int16>)(result), values, isUnsafe: false);
object unsafeResult = typeof(Vector64<Int16>)
- .GetMethod(nameof(Vector64<Int16>.ToVector128), new Type[] { })
+ .GetMethod(nameof(Vector64.ToVector128), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<Int16>)(unsafeResult), values, isUnsafe: true);
}
Vector64<Int32> value = Vector64.Create(values[0], values[1]);
object result = typeof(Vector64<Int32>)
- .GetMethod(nameof(Vector64<Int32>.ToVector128), new Type[] { })
+ .GetMethod(nameof(Vector64.ToVector128), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<Int32>)(result), values, isUnsafe: false);
object unsafeResult = typeof(Vector64<Int32>)
- .GetMethod(nameof(Vector64<Int32>.ToVector128), new Type[] { })
+ .GetMethod(nameof(Vector64.ToVector128), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<Int32>)(unsafeResult), values, isUnsafe: true);
}
Vector64<Int64> value = Vector64.Create(values[0]);
object result = typeof(Vector64<Int64>)
- .GetMethod(nameof(Vector64<Int64>.ToVector128), new Type[] { })
+ .GetMethod(nameof(Vector64.ToVector128), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<Int64>)(result), values, isUnsafe: false);
object unsafeResult = typeof(Vector64<Int64>)
- .GetMethod(nameof(Vector64<Int64>.ToVector128), new Type[] { })
+ .GetMethod(nameof(Vector64.ToVector128), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<Int64>)(unsafeResult), values, isUnsafe: true);
}
Vector64<SByte> value = Vector64.Create(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7]);
object result = typeof(Vector64<SByte>)
- .GetMethod(nameof(Vector64<SByte>.ToVector128), new Type[] { })
+ .GetMethod(nameof(Vector64.ToVector128), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<SByte>)(result), values, isUnsafe: false);
object unsafeResult = typeof(Vector64<SByte>)
- .GetMethod(nameof(Vector64<SByte>.ToVector128), new Type[] { })
+ .GetMethod(nameof(Vector64.ToVector128), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<SByte>)(unsafeResult), values, isUnsafe: true);
}
Vector64<Single> value = Vector64.Create(values[0], values[1]);
object result = typeof(Vector64<Single>)
- .GetMethod(nameof(Vector64<Single>.ToVector128), new Type[] { })
+ .GetMethod(nameof(Vector64.ToVector128), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<Single>)(result), values, isUnsafe: false);
object unsafeResult = typeof(Vector64<Single>)
- .GetMethod(nameof(Vector64<Single>.ToVector128), new Type[] { })
+ .GetMethod(nameof(Vector64.ToVector128), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<Single>)(unsafeResult), values, isUnsafe: true);
}
Vector64<UInt16> value = Vector64.Create(values[0], values[1], values[2], values[3]);
object result = typeof(Vector64<UInt16>)
- .GetMethod(nameof(Vector64<UInt16>.ToVector128), new Type[] { })
+ .GetMethod(nameof(Vector64.ToVector128), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<UInt16>)(result), values, isUnsafe: false);
object unsafeResult = typeof(Vector64<UInt16>)
- .GetMethod(nameof(Vector64<UInt16>.ToVector128), new Type[] { })
+ .GetMethod(nameof(Vector64.ToVector128), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<UInt16>)(unsafeResult), values, isUnsafe: true);
}
Vector64<UInt32> value = Vector64.Create(values[0], values[1]);
object result = typeof(Vector64<UInt32>)
- .GetMethod(nameof(Vector64<UInt32>.ToVector128), new Type[] { })
+ .GetMethod(nameof(Vector64.ToVector128), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<UInt32>)(result), values, isUnsafe: false);
object unsafeResult = typeof(Vector64<UInt32>)
- .GetMethod(nameof(Vector64<UInt32>.ToVector128), new Type[] { })
+ .GetMethod(nameof(Vector64.ToVector128), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<UInt32>)(unsafeResult), values, isUnsafe: true);
}
Vector64<UInt64> value = Vector64.Create(values[0]);
object result = typeof(Vector64<UInt64>)
- .GetMethod(nameof(Vector64<UInt64>.ToVector128), new Type[] { })
+ .GetMethod(nameof(Vector64.ToVector128), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<UInt64>)(result), values, isUnsafe: false);
object unsafeResult = typeof(Vector64<UInt64>)
- .GetMethod(nameof(Vector64<UInt64>.ToVector128), new Type[] { })
+ .GetMethod(nameof(Vector64.ToVector128), new Type[] { })
.Invoke(value, new object[] { });
ValidateResult((Vector128<UInt64>)(unsafeResult), values, isUnsafe: true);
}
{
if (typeof(T) == typeof(byte))
{
- return Sse2.Add(left.AsByte(), right.AsByte()).As<T>();
+ return Sse2.Add(left.AsByte(), right.AsByte()).As<byte, T>();
}
else if (typeof(T) == typeof(sbyte))
{
- return Sse2.Add(left.AsSByte(), right.AsSByte()).As<T>();
+ return Sse2.Add(left.AsSByte(), right.AsSByte()).As<sbyte, T>();
}
else if (typeof(T) == typeof(short))
{
- return Sse2.Add(left.AsInt16(), right.AsInt16()).As<T>();
+ return Sse2.Add(left.AsInt16(), right.AsInt16()).As<short, T>();
}
else if (typeof(T) == typeof(ushort))
{
- return Sse2.Add(left.AsUInt16(), right.AsUInt16()).As<T>();
+ return Sse2.Add(left.AsUInt16(), right.AsUInt16()).As<ushort, T>();
}
else if (typeof(T) == typeof(int))
{
- return Sse2.Add(left.AsInt32(), right.AsInt32()).As<T>();
+ return Sse2.Add(left.AsInt32(), right.AsInt32()).As<int, T>();
}
else if (typeof(T) == typeof(uint))
{
- return Sse2.Add(left.AsUInt32(), right.AsUInt32()).As<T>();
+ return Sse2.Add(left.AsUInt32(), right.AsUInt32()).As<uint, T>();
}
else if (typeof(T) == typeof(long))
{
- return Sse2.Add(left.AsInt64(), right.AsInt64()).As<T>();
+ return Sse2.Add(left.AsInt64(), right.AsInt64()).As<long, T>();
}
else if (typeof(T) == typeof(ulong))
{
- return Sse2.Add(left.AsUInt64(), right.AsUInt64()).As<T>();
+ return Sse2.Add(left.AsUInt64(), right.AsUInt64()).As<ulong, T>();
}
else if (typeof(T) == typeof(float))
{
- return Sse.Add(left.AsSingle(), right.AsSingle()).As<T>();
+ return Sse.Add(left.AsSingle(), right.AsSingle()).As<float, T>();
}
else if (typeof(T) == typeof(double))
{
- return Sse2.Add(left.AsDouble(), right.AsDouble()).As<T>();
+ return Sse2.Add(left.AsDouble(), right.AsDouble()).As<double, T>();
}
else
{
{
if (typeof(T) == typeof(byte))
{
- return Avx2.Add(left.AsByte(), right.AsByte()).As<T>();
+ return Avx2.Add(left.AsByte(), right.AsByte()).As<byte, T>();
}
else if (typeof(T) == typeof(sbyte))
{
- return Avx2.Add(left.AsSByte(), right.AsSByte()).As<T>();
+ return Avx2.Add(left.AsSByte(), right.AsSByte()).As<sbyte, T>();
}
else if (typeof(T) == typeof(short))
{
- return Avx2.Add(left.AsInt16(), right.AsInt16()).As<T>();
+ return Avx2.Add(left.AsInt16(), right.AsInt16()).As<short, T>();
}
else if (typeof(T) == typeof(ushort))
{
- return Avx2.Add(left.AsUInt16(), right.AsUInt16()).As<T>();
+ return Avx2.Add(left.AsUInt16(), right.AsUInt16()).As<ushort, T>();
}
else if (typeof(T) == typeof(int))
{
- return Avx2.Add(left.AsInt32(), right.AsInt32()).As<T>();
+ return Avx2.Add(left.AsInt32(), right.AsInt32()).As<int, T>();
}
else if (typeof(T) == typeof(uint))
{
- return Avx2.Add(left.AsUInt32(), right.AsUInt32()).As<T>();
+ return Avx2.Add(left.AsUInt32(), right.AsUInt32()).As<uint, T>();
}
else if (typeof(T) == typeof(long))
{
- return Avx2.Add(left.AsInt64(), right.AsInt64()).As<T>();
+ return Avx2.Add(left.AsInt64(), right.AsInt64()).As<long, T>();
}
else if (typeof(T) == typeof(ulong))
{
- return Avx2.Add(left.AsUInt64(), right.AsUInt64()).As<T>();
+ return Avx2.Add(left.AsUInt64(), right.AsUInt64()).As<ulong, T>();
}
else if (typeof(T) == typeof(float))
{
- return Avx.Add(left.AsSingle(), right.AsSingle()).As<T>();
+ return Avx.Add(left.AsSingle(), right.AsSingle()).As<float, T>();
}
else if (typeof(T) == typeof(double))
{
- return Avx.Add(left.AsDouble(), right.AsDouble()).As<T>();
+ return Avx.Add(left.AsDouble(), right.AsDouble()).As<double, T>();
}
else
{
{
if (typeof(T) == typeof(byte))
{
- return Vector128.Create(Convert.ToByte(value)).As<T>();
+ return Vector128.Create(Convert.ToByte(value)).As<byte, T>();
}
else if (typeof(T) == typeof(sbyte))
{
- return Vector128.Create(Convert.ToSByte(value)).As<T>();
+ return Vector128.Create(Convert.ToSByte(value)).As<sbyte, T>();
}
else if (typeof(T) == typeof(short))
{
- return Vector128.Create(Convert.ToInt16(value)).As<T>();
+ return Vector128.Create(Convert.ToInt16(value)).As<short, T>();
}
else if (typeof(T) == typeof(ushort))
{
- return Vector128.Create(Convert.ToUInt16(value)).As<T>();
+ return Vector128.Create(Convert.ToUInt16(value)).As<ushort, T>();
}
else if (typeof(T) == typeof(int))
{
- return Vector128.Create(Convert.ToInt32(value)).As<T>();
+ return Vector128.Create(Convert.ToInt32(value)).As<int, T>();
}
else if (typeof(T) == typeof(uint))
{
- return Vector128.Create(Convert.ToUInt32(value)).As<T>();
+ return Vector128.Create(Convert.ToUInt32(value)).As<uint, T>();
}
else if (typeof(T) == typeof(long))
{
- return Vector128.Create(Convert.ToInt64(value)).As<T>();
+ return Vector128.Create(Convert.ToInt64(value)).As<long, T>();
}
else if (typeof(T) == typeof(ulong))
{
- return Vector128.Create(Convert.ToUInt64(value)).As<T>();
+ return Vector128.Create(Convert.ToUInt64(value)).As<ulong, T>();
}
else if (typeof(T) == typeof(float))
{
- return Vector128.Create(Convert.ToSingle(value)).As<T>();
+ return Vector128.Create(Convert.ToSingle(value)).As<float, T>();
}
else if (typeof(T) == typeof(double))
{
- return Vector128.Create(Convert.ToDouble(value)).As<T>();
+ return Vector128.Create(Convert.ToDouble(value)).As<double, T>();
}
else
{
{
if (typeof(T) == typeof(byte))
{
- return Vector256.Create(Convert.ToByte(value)).As<T>();
+ return Vector256.Create(Convert.ToByte(value)).As<byte, T>();
}
else if (typeof(T) == typeof(sbyte))
{
- return Vector256.Create(Convert.ToSByte(value)).As<T>();
+ return Vector256.Create(Convert.ToSByte(value)).As<sbyte, T>();
}
else if (typeof(T) == typeof(short))
{
- return Vector256.Create(Convert.ToInt16(value)).As<T>();
+ return Vector256.Create(Convert.ToInt16(value)).As<short, T>();
}
else if (typeof(T) == typeof(ushort))
{
- return Vector256.Create(Convert.ToUInt16(value)).As<T>();
+ return Vector256.Create(Convert.ToUInt16(value)).As<ushort, T>();
}
else if (typeof(T) == typeof(int))
{
- return Vector256.Create(Convert.ToInt32(value)).As<T>();
+ return Vector256.Create(Convert.ToInt32(value)).As<int, T>();
}
else if (typeof(T) == typeof(uint))
{
- return Vector256.Create(Convert.ToUInt32(value)).As<T>();
+ return Vector256.Create(Convert.ToUInt32(value)).As<uint, T>();
}
else if (typeof(T) == typeof(long))
{
- return Vector256.Create(Convert.ToInt64(value)).As<T>();
+ return Vector256.Create(Convert.ToInt64(value)).As<long, T>();
}
else if (typeof(T) == typeof(ulong))
{
- return Vector256.Create(Convert.ToUInt64(value)).As<T>();
+ return Vector256.Create(Convert.ToUInt64(value)).As<ulong, T>();
}
else if (typeof(T) == typeof(float))
{
- return Vector256.Create(Convert.ToSingle(value)).As<T>();
+ return Vector256.Create(Convert.ToSingle(value)).As<float, T>();
}
else if (typeof(T) == typeof(double))
{
- return Vector256.Create(Convert.ToDouble(value)).As<T>();
+ return Vector256.Create(Convert.ToDouble(value)).As<double, T>();
}
else
{
projects / platform / upstream / dotnet / runtime.git / commitdiff