QWERTYkez/QWERTYkez.Mensura
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

tests

Browse Source
This commit is contained in:
melekhin
2026-06-11 15:42:01 +07:00
parent 343996ef46
commit 790a5f8e10
35 changed files with 5128 additions and 3595 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1170
QWERTYkez.Mensura.Generator/ComplexUnitGenerator.cs
View File

File diff suppressed because it is too large Load Diff

524
QWERTYkez.Mensura.Generator/UnitGenerator.cs
View File

@@ -577,6 +577,498 @@ public readonly partial record struct {typeName} : IMensuraUnit<{typeName}>, IEq
public static {typeName}[] operator /({typeName}? T1, UInt128[] T2) => T1.ProtectedU().Div(T2.ToDouble());
public static {typeName}?[] operator /({typeName}? T1, UInt128?[] T2) => T1.ProtectedU().Div(T2.ToDouble());
#endif
public static List<{typeName}> operator +(List<{typeName}> T1, {typeName} T2) => T1.Plus(T2._Value);
public static List<{typeName}?> operator +(List<{typeName}?> T1, {typeName} T2) => T1.Plus(T2._Value);
public static List<{typeName}> operator +({typeName} T1, List<{typeName}> T2) => T1._Value.Plus(T2);
public static List<{typeName}?> operator +({typeName} T1, List<{typeName}?> T2) => T1._Value.Plus(T2);
public static List<{typeName}> operator +(List<{typeName}> T1, {typeName}? T2) => T1.Plus(T2.Protected());
public static List<{typeName}?> operator +(List<{typeName}?> T1, {typeName}? T2) => T1.Plus(T2.Protected());
public static List<{typeName}> operator +({typeName}? T1, List<{typeName}> T2) => T1.Protected().Plus(T2);
public static List<{typeName}?> operator +({typeName}? T1, List<{typeName}?> T2) => T1.Protected().Plus(T2);
public static List<{typeName}> operator -(List<{typeName}> T1, {typeName} T2) => T1.Minus(T2._Value);
public static List<{typeName}?> operator -(List<{typeName}?> T1, {typeName} T2) => T1.Minus(T2._Value);
public static List<{typeName}> operator -({typeName} T1, List<{typeName}> T2) => T1._Value.Minus(T2);
public static List<{typeName}?> operator -({typeName} T1, List<{typeName}?> T2) => T1._Value.Minus(T2);
public static List<{typeName}> operator -(List<{typeName}> T1, {typeName}? T2) => T1.Minus(T2.Protected());
public static List<{typeName}?> operator -(List<{typeName}?> T1, {typeName}? T2) => T1.Minus(T2.Protected());
public static List<{typeName}> operator -({typeName}? T1, List<{typeName}> T2) => T1.Protected().Minus(T2);
public static List<{typeName}?> operator -({typeName}? T1, List<{typeName}?> T2) => T1.Protected().Minus(T2);
public static List<double> operator /({typeName} T1, List<{typeName}> T2) => T1.Div(T2);
public static List<double?> operator /({typeName} T1, List<{typeName}?> T2) => T1.Div(T2);
public static List<double> operator /(List<{typeName}> T1, {typeName} T2) => T1.Div(T2);
public static List<double?> operator /(List<{typeName}?> T1, {typeName} T2) => T1.Div(T2);
public static List<double> operator /({typeName}? T1, List<{typeName}> T2) => T1.ProtectedU().Div(T2);
public static List<double?> operator /({typeName}? T1, List<{typeName}?> T2) => T1.ProtectedU().Div(T2);
public static List<double> operator /(List<{typeName}> T1, {typeName}? T2) => T1.Div(T2.ProtectedU());
public static List<double?> operator /(List<{typeName}?> T1, {typeName}? T2) => T1.Div(T2.ProtectedU());
// double
public static List<{typeName}> operator *({typeName} T1, List<double> T2) => T1.Mul(T2);
public static List<{typeName}?> operator *({typeName} T1, List<double?> T2) => T1.Mul(T2);
public static List<{typeName}> operator *({typeName}? T1, List<double> T2) => T1.ProtectedU().Mul(T2);
public static List<{typeName}?> operator *({typeName}? T1, List<double?> T2) => T1.ProtectedU().Mul(T2);
public static List<{typeName}> operator *(List<double> T1, {typeName} T2) => T1.Mul(T2);
public static List<{typeName}?> operator *(List<double?> T1, {typeName} T2) => T1.Mul(T2);
public static List<{typeName}> operator *(List<double> T1, {typeName}? T2) => T1.Mul(T2.ProtectedU());
public static List<{typeName}?> operator *(List<double?> T1, {typeName}? T2) => T1.Mul(T2.ProtectedU());
public static List<{typeName}> operator /({typeName} T1, List<double> T2) => T1.Div(T2);
public static List<{typeName}?> operator /({typeName} T1, List<double?> T2) => T1.Div(T2);
public static List<{typeName}> operator /({typeName}? T1, List<double> T2) => T1.ProtectedU().Div(T2);
public static List<{typeName}?> operator /({typeName}? T1, List<double?> T2) => T1.ProtectedU().Div(T2);
// sbyte
public static List<{typeName}> operator *({typeName} T1, List<sbyte> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName} T1, List<sbyte?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}> operator *({typeName}? T1, List<sbyte> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName}? T1, List<sbyte?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}> operator *(List<sbyte> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}?> operator *(List<sbyte?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}> operator *(List<sbyte> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}?> operator *(List<sbyte?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}> operator /({typeName} T1, List<sbyte> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName} T1, List<sbyte?> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}> operator /({typeName}? T1, List<sbyte> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName}? T1, List<sbyte?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// short
public static List<{typeName}> operator *({typeName} T1, List<short> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName} T1, List<short?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}> operator *({typeName}? T1, List<short> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName}? T1, List<short?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}> operator *(List<short> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}?> operator *(List<short?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}> operator *(List<short> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}?> operator *(List<short?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}> operator /({typeName} T1, List<short> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName} T1, List<short?> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}> operator /({typeName}? T1, List<short> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName}? T1, List<short?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// int
public static List<{typeName}> operator *({typeName} T1, List<int> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName} T1, List<int?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}> operator *({typeName}? T1, List<int> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName}? T1, List<int?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}> operator *(List<int> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}?> operator *(List<int?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}> operator *(List<int> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}?> operator *(List<int?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}> operator /({typeName} T1, List<int> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName} T1, List<int?> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}> operator /({typeName}? T1, List<int> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName}? T1, List<int?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// long
public static List<{typeName}> operator *({typeName} T1, List<long> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName} T1, List<long?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}> operator *({typeName}? T1, List<long> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName}? T1, List<long?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}> operator *(List<long> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}?> operator *(List<long?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}> operator *(List<long> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}?> operator *(List<long?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}> operator /({typeName} T1, List<long> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName} T1, List<long?> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}> operator /({typeName}? T1, List<long> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName}? T1, List<long?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// byte
public static List<{typeName}> operator *({typeName} T1, List<byte> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName} T1, List<byte?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}> operator *({typeName}? T1, List<byte> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName}? T1, List<byte?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}> operator *(List<byte> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}?> operator *(List<byte?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}> operator *(List<byte> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}?> operator *(List<byte?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}> operator /({typeName} T1, List<byte> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName} T1, List<byte?> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}> operator /({typeName}? T1, List<byte> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName}? T1, List<byte?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// ushort
public static List<{typeName}> operator *({typeName} T1, List<ushort> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName} T1, List<ushort?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}> operator *({typeName}? T1, List<ushort> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName}? T1, List<ushort?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}> operator *(List<ushort> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}?> operator *(List<ushort?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}> operator *(List<ushort> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}?> operator *(List<ushort?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}> operator /({typeName} T1, List<ushort> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName} T1, List<ushort?> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}> operator /({typeName}? T1, List<ushort> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName}? T1, List<ushort?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// uint
public static List<{typeName}> operator *({typeName} T1, List<uint> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName} T1, List<uint?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}> operator *({typeName}? T1, List<uint> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName}? T1, List<uint?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}> operator *(List<uint> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}?> operator *(List<uint?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}> operator *(List<uint> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}?> operator *(List<uint?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}> operator /({typeName} T1, List<uint> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName} T1, List<uint?> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}> operator /({typeName}? T1, List<uint> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName}? T1, List<uint?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// ulong
public static List<{typeName}> operator *({typeName} T1, List<ulong> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName} T1, List<ulong?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}> operator *({typeName}? T1, List<ulong> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName}? T1, List<ulong?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}> operator *(List<ulong> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}?> operator *(List<ulong?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}> operator *(List<ulong> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}?> operator *(List<ulong?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}> operator /({typeName} T1, List<ulong> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName} T1, List<ulong?> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}> operator /({typeName}? T1, List<ulong> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName}? T1, List<ulong?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// nint
public static List<{typeName}> operator *({typeName} T1, List<nint> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName} T1, List<nint?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}> operator *({typeName}? T1, List<nint> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName}? T1, List<nint?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}> operator *(List<nint> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}?> operator *(List<nint?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}> operator *(List<nint> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}?> operator *(List<nint?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}> operator /({typeName} T1, List<nint> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName} T1, List<nint?> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}> operator /({typeName}? T1, List<nint> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName}? T1, List<nint?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// nuint
public static List<{typeName}> operator *({typeName} T1, List<nuint> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName} T1, List<nuint?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}> operator *({typeName}? T1, List<nuint> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName}? T1, List<nuint?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}> operator *(List<nuint> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}?> operator *(List<nuint?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}> operator *(List<nuint> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}?> operator *(List<nuint?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}> operator /({typeName} T1, List<nuint> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName} T1, List<nuint?> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}> operator /({typeName}? T1, List<nuint> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName}? T1, List<nuint?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// float
public static List<{typeName}> operator *({typeName} T1, List<float> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName} T1, List<float?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}> operator *({typeName}? T1, List<float> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName}? T1, List<float?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}> operator *(List<float> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}?> operator *(List<float?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}> operator *(List<float> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}?> operator *(List<float?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}> operator /({typeName} T1, List<float> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName} T1, List<float?> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}> operator /({typeName}? T1, List<float> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName}? T1, List<float?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// decimal
public static List<{typeName}> operator *({typeName} T1, List<decimal> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName} T1, List<decimal?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}> operator *({typeName}? T1, List<decimal> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName}? T1, List<decimal?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}> operator *(List<decimal> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}?> operator *(List<decimal?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}> operator *(List<decimal> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}?> operator *(List<decimal?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}> operator /({typeName} T1, List<decimal> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName} T1, List<decimal?> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}> operator /({typeName}? T1, List<decimal> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName}? T1, List<decimal?> T2) => T1.ProtectedU().Div(T2.ToDouble());
#if NET7_0_OR_GREATER
// Int128
public static List<{typeName}> operator *({typeName} T1, List<Int128> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName} T1, List<Int128?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}> operator *({typeName}? T1, List<Int128> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName}? T1, List<Int128?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}> operator *(List<Int128> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}?> operator *(List<Int128?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}> operator *(List<Int128> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}?> operator *(List<Int128?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}> operator /({typeName} T1, List<Int128> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName} T1, List<Int128?> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}> operator /({typeName}? T1, List<Int128> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName}? T1, List<Int128?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// UInt128
public static List<{typeName}> operator *({typeName} T1, List<UInt128> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName} T1, List<UInt128?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeName}> operator *({typeName}? T1, List<UInt128> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}?> operator *({typeName}? T1, List<UInt128?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeName}> operator *(List<UInt128> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}?> operator *(List<UInt128?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static List<{typeName}> operator *(List<UInt128> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}?> operator *(List<UInt128?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeName}> operator /({typeName} T1, List<UInt128> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName} T1, List<UInt128?> T2) => T1.Div(T2.ToDouble());
public static List<{typeName}> operator /({typeName}? T1, List<UInt128> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeName}?> operator /({typeName}? T1, List<UInt128?> T2) => T1.ProtectedU().Div(T2.ToDouble());
#endif
public static IEnumerable<{typeName}> operator +(IEnumerable<{typeName}> T1, {typeName} T2) => T1.Plus(T2._Value);
public static IEnumerable<{typeName}?> operator +(IEnumerable<{typeName}?> T1, {typeName} T2) => T1.Plus(T2._Value);
public static IEnumerable<{typeName}> operator +({typeName} T1, IEnumerable<{typeName}> T2) => T1._Value.Plus(T2);
public static IEnumerable<{typeName}?> operator +({typeName} T1, IEnumerable<{typeName}?> T2) => T1._Value.Plus(T2);
public static IEnumerable<{typeName}> operator +(IEnumerable<{typeName}> T1, {typeName}? T2) => T1.Plus(T2.Protected());
public static IEnumerable<{typeName}?> operator +(IEnumerable<{typeName}?> T1, {typeName}? T2) => T1.Plus(T2.Protected());
public static IEnumerable<{typeName}> operator +({typeName}? T1, IEnumerable<{typeName}> T2) => T1.Protected().Plus(T2);
public static IEnumerable<{typeName}?> operator +({typeName}? T1, IEnumerable<{typeName}?> T2) => T1.Protected().Plus(T2);
public static IEnumerable<{typeName}> operator -(IEnumerable<{typeName}> T1, {typeName} T2) => T1.Minus(T2._Value);
public static IEnumerable<{typeName}?> operator -(IEnumerable<{typeName}?> T1, {typeName} T2) => T1.Minus(T2._Value);
public static IEnumerable<{typeName}> operator -({typeName} T1, IEnumerable<{typeName}> T2) => T1._Value.Minus(T2);
public static IEnumerable<{typeName}?> operator -({typeName} T1, IEnumerable<{typeName}?> T2) => T1._Value.Minus(T2);
public static IEnumerable<{typeName}> operator -(IEnumerable<{typeName}> T1, {typeName}? T2) => T1.Minus(T2.Protected());
public static IEnumerable<{typeName}?> operator -(IEnumerable<{typeName}?> T1, {typeName}? T2) => T1.Minus(T2.Protected());
public static IEnumerable<{typeName}> operator -({typeName}? T1, IEnumerable<{typeName}> T2) => T1.Protected().Minus(T2);
public static IEnumerable<{typeName}?> operator -({typeName}? T1, IEnumerable<{typeName}?> T2) => T1.Protected().Minus(T2);
public static IEnumerable<double> operator /({typeName} T1, IEnumerable<{typeName}> T2) => T1.Div(T2);
public static IEnumerable<double?> operator /({typeName} T1, IEnumerable<{typeName}?> T2) => T1.Div(T2);
public static IEnumerable<double> operator /(IEnumerable<{typeName}> T1, {typeName} T2) => T1.Div(T2);
public static IEnumerable<double?> operator /(IEnumerable<{typeName}?> T1, {typeName} T2) => T1.Div(T2);
public static IEnumerable<double> operator /({typeName}? T1, IEnumerable<{typeName}> T2) => T1.ProtectedU().Div(T2);
public static IEnumerable<double?> operator /({typeName}? T1, IEnumerable<{typeName}?> T2) => T1.ProtectedU().Div(T2);
public static IEnumerable<double> operator /(IEnumerable<{typeName}> T1, {typeName}? T2) => T1.Div(T2.ProtectedU());
public static IEnumerable<double?> operator /(IEnumerable<{typeName}?> T1, {typeName}? T2) => T1.Div(T2.ProtectedU());
// double
public static IEnumerable<{typeName}> operator *({typeName} T1, IEnumerable<double> T2) => T1.Mul(T2);
public static IEnumerable<{typeName}?> operator *({typeName} T1, IEnumerable<double?> T2) => T1.Mul(T2);
public static IEnumerable<{typeName}> operator *({typeName}? T1, IEnumerable<double> T2) => T1.ProtectedU().Mul(T2);
public static IEnumerable<{typeName}?> operator *({typeName}? T1, IEnumerable<double?> T2) => T1.ProtectedU().Mul(T2);
public static IEnumerable<{typeName}> operator *(IEnumerable<double> T1, {typeName} T2) => T1.Mul(T2);
public static IEnumerable<{typeName}?> operator *(IEnumerable<double?> T1, {typeName} T2) => T1.Mul(T2);
public static IEnumerable<{typeName}> operator *(IEnumerable<double> T1, {typeName}? T2) => T1.Mul(T2.ProtectedU());
public static IEnumerable<{typeName}?> operator *(IEnumerable<double?> T1, {typeName}? T2) => T1.Mul(T2.ProtectedU());
public static IEnumerable<{typeName}> operator /({typeName} T1, IEnumerable<double> T2) => T1.Div(T2);
public static IEnumerable<{typeName}?> operator /({typeName} T1, IEnumerable<double?> T2) => T1.Div(T2);
public static IEnumerable<{typeName}> operator /({typeName}? T1, IEnumerable<double> T2) => T1.ProtectedU().Div(T2);
public static IEnumerable<{typeName}?> operator /({typeName}? T1, IEnumerable<double?> T2) => T1.ProtectedU().Div(T2);
// sbyte
public static IEnumerable<{typeName}> operator *({typeName} T1, IEnumerable<sbyte> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName} T1, IEnumerable<sbyte?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *({typeName}? T1, IEnumerable<sbyte> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName}? T1, IEnumerable<sbyte?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *(IEnumerable<sbyte> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}?> operator *(IEnumerable<sbyte?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}> operator *(IEnumerable<sbyte> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}?> operator *(IEnumerable<sbyte?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}> operator /({typeName} T1, IEnumerable<sbyte> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName} T1, IEnumerable<sbyte?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}> operator /({typeName}? T1, IEnumerable<sbyte> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName}? T1, IEnumerable<sbyte?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// short
public static IEnumerable<{typeName}> operator *({typeName} T1, IEnumerable<short> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName} T1, IEnumerable<short?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *({typeName}? T1, IEnumerable<short> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName}? T1, IEnumerable<short?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *(IEnumerable<short> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}?> operator *(IEnumerable<short?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}> operator *(IEnumerable<short> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}?> operator *(IEnumerable<short?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}> operator /({typeName} T1, IEnumerable<short> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName} T1, IEnumerable<short?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}> operator /({typeName}? T1, IEnumerable<short> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName}? T1, IEnumerable<short?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// int
public static IEnumerable<{typeName}> operator *({typeName} T1, IEnumerable<int> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName} T1, IEnumerable<int?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *({typeName}? T1, IEnumerable<int> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName}? T1, IEnumerable<int?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *(IEnumerable<int> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}?> operator *(IEnumerable<int?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}> operator *(IEnumerable<int> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}?> operator *(IEnumerable<int?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}> operator /({typeName} T1, IEnumerable<int> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName} T1, IEnumerable<int?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}> operator /({typeName}? T1, IEnumerable<int> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName}? T1, IEnumerable<int?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// long
public static IEnumerable<{typeName}> operator *({typeName} T1, IEnumerable<long> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName} T1, IEnumerable<long?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *({typeName}? T1, IEnumerable<long> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName}? T1, IEnumerable<long?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *(IEnumerable<long> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}?> operator *(IEnumerable<long?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}> operator *(IEnumerable<long> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}?> operator *(IEnumerable<long?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}> operator /({typeName} T1, IEnumerable<long> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName} T1, IEnumerable<long?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}> operator /({typeName}? T1, IEnumerable<long> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName}? T1, IEnumerable<long?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// byte
public static IEnumerable<{typeName}> operator *({typeName} T1, IEnumerable<byte> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName} T1, IEnumerable<byte?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *({typeName}? T1, IEnumerable<byte> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName}? T1, IEnumerable<byte?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *(IEnumerable<byte> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}?> operator *(IEnumerable<byte?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}> operator *(IEnumerable<byte> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}?> operator *(IEnumerable<byte?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}> operator /({typeName} T1, IEnumerable<byte> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName} T1, IEnumerable<byte?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}> operator /({typeName}? T1, IEnumerable<byte> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName}? T1, IEnumerable<byte?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// ushort
public static IEnumerable<{typeName}> operator *({typeName} T1, IEnumerable<ushort> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName} T1, IEnumerable<ushort?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *({typeName}? T1, IEnumerable<ushort> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName}? T1, IEnumerable<ushort?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *(IEnumerable<ushort> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}?> operator *(IEnumerable<ushort?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}> operator *(IEnumerable<ushort> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}?> operator *(IEnumerable<ushort?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}> operator /({typeName} T1, IEnumerable<ushort> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName} T1, IEnumerable<ushort?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}> operator /({typeName}? T1, IEnumerable<ushort> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName}? T1, IEnumerable<ushort?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// uint
public static IEnumerable<{typeName}> operator *({typeName} T1, IEnumerable<uint> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName} T1, IEnumerable<uint?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *({typeName}? T1, IEnumerable<uint> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName}? T1, IEnumerable<uint?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *(IEnumerable<uint> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}?> operator *(IEnumerable<uint?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}> operator *(IEnumerable<uint> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}?> operator *(IEnumerable<uint?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}> operator /({typeName} T1, IEnumerable<uint> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName} T1, IEnumerable<uint?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}> operator /({typeName}? T1, IEnumerable<uint> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName}? T1, IEnumerable<uint?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// ulong
public static IEnumerable<{typeName}> operator *({typeName} T1, IEnumerable<ulong> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName} T1, IEnumerable<ulong?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *({typeName}? T1, IEnumerable<ulong> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName}? T1, IEnumerable<ulong?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *(IEnumerable<ulong> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}?> operator *(IEnumerable<ulong?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}> operator *(IEnumerable<ulong> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}?> operator *(IEnumerable<ulong?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}> operator /({typeName} T1, IEnumerable<ulong> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName} T1, IEnumerable<ulong?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}> operator /({typeName}? T1, IEnumerable<ulong> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName}? T1, IEnumerable<ulong?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// nint
public static IEnumerable<{typeName}> operator *({typeName} T1, IEnumerable<nint> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName} T1, IEnumerable<nint?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *({typeName}? T1, IEnumerable<nint> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName}? T1, IEnumerable<nint?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *(IEnumerable<nint> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}?> operator *(IEnumerable<nint?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}> operator *(IEnumerable<nint> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}?> operator *(IEnumerable<nint?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}> operator /({typeName} T1, IEnumerable<nint> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName} T1, IEnumerable<nint?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}> operator /({typeName}? T1, IEnumerable<nint> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName}? T1, IEnumerable<nint?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// nuint
public static IEnumerable<{typeName}> operator *({typeName} T1, IEnumerable<nuint> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName} T1, IEnumerable<nuint?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *({typeName}? T1, IEnumerable<nuint> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName}? T1, IEnumerable<nuint?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *(IEnumerable<nuint> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}?> operator *(IEnumerable<nuint?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}> operator *(IEnumerable<nuint> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}?> operator *(IEnumerable<nuint?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}> operator /({typeName} T1, IEnumerable<nuint> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName} T1, IEnumerable<nuint?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}> operator /({typeName}? T1, IEnumerable<nuint> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName}? T1, IEnumerable<nuint?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// float
public static IEnumerable<{typeName}> operator *({typeName} T1, IEnumerable<float> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName} T1, IEnumerable<float?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *({typeName}? T1, IEnumerable<float> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName}? T1, IEnumerable<float?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *(IEnumerable<float> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}?> operator *(IEnumerable<float?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}> operator *(IEnumerable<float> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}?> operator *(IEnumerable<float?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}> operator /({typeName} T1, IEnumerable<float> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName} T1, IEnumerable<float?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}> operator /({typeName}? T1, IEnumerable<float> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName}? T1, IEnumerable<float?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// decimal
public static IEnumerable<{typeName}> operator *({typeName} T1, IEnumerable<decimal> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName} T1, IEnumerable<decimal?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *({typeName}? T1, IEnumerable<decimal> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName}? T1, IEnumerable<decimal?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *(IEnumerable<decimal> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}?> operator *(IEnumerable<decimal?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}> operator *(IEnumerable<decimal> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}?> operator *(IEnumerable<decimal?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}> operator /({typeName} T1, IEnumerable<decimal> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName} T1, IEnumerable<decimal?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}> operator /({typeName}? T1, IEnumerable<decimal> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName}? T1, IEnumerable<decimal?> T2) => T1.ProtectedU().Div(T2.ToDouble());
#if NET7_0_OR_GREATER
// Int128
public static IEnumerable<{typeName}> operator *({typeName} T1, IEnumerable<Int128> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName} T1, IEnumerable<Int128?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *({typeName}? T1, IEnumerable<Int128> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName}? T1, IEnumerable<Int128?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *(IEnumerable<Int128> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}?> operator *(IEnumerable<Int128?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}> operator *(IEnumerable<Int128> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}?> operator *(IEnumerable<Int128?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}> operator /({typeName} T1, IEnumerable<Int128> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName} T1, IEnumerable<Int128?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}> operator /({typeName}? T1, IEnumerable<Int128> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName}? T1, IEnumerable<Int128?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// UInt128
public static IEnumerable<{typeName}> operator *({typeName} T1, IEnumerable<UInt128> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName} T1, IEnumerable<UInt128?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *({typeName}? T1, IEnumerable<UInt128> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}?> operator *({typeName}? T1, IEnumerable<UInt128?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeName}> operator *(IEnumerable<UInt128> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}?> operator *(IEnumerable<UInt128?> T1, {typeName} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeName}> operator *(IEnumerable<UInt128> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}?> operator *(IEnumerable<UInt128?> T1, {typeName}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeName}> operator /({typeName} T1, IEnumerable<UInt128> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName} T1, IEnumerable<UInt128?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeName}> operator /({typeName}? T1, IEnumerable<UInt128> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeName}?> operator /({typeName}? T1, IEnumerable<UInt128?> T2) => T1.ProtectedU().Div(T2.ToDouble());
#endif
}
public static class {typeName}Extensions
@@ -619,16 +1111,6 @@ public static class {typeName}Extensions
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeName}?> Div(
this double dividend, List<{typeName}?> units) => dividend.Div<{typeName}>(units);
// === ICollection<T> ===
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static void Div(this ICollection<{typeName}> units,
double divisor, Span<{typeName}> destination) => units.Div<{typeName}>(divisor, destination);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static void Div(this ICollection<{typeName}?> units,
double divisor, Span<{typeName}?> destination) => units.Div<{typeName}>(divisor, destination);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static void Div(this double dividend,
ICollection<{typeName}> units, Span<{typeName}> destination) => dividend.Div<{typeName}>(units, destination);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static void Div(this double dividend,
ICollection<{typeName}?> units, Span<{typeName}?> destination) => dividend.Div<{typeName}>(units, destination);
// === IReadOnlyCollection<T> ===
[MethodImpl(MethodImplOptions.AggressiveInlining)]public static void Div(this IReadOnlyCollection<{typeName}> units,
double divisor, Span<{typeName}> destination) => units.Div<{typeName}>(divisor, destination);
@@ -684,16 +1166,6 @@ public static class {typeName}Extensions
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeName}?> Mul(
this double multiplicator, List<{typeName}?> units) => units.Mul<{typeName}>(multiplicator);
// === ICollection<T> ===
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static void Mul(this ICollection<{typeName}> units,
double multiplicator, Span<{typeName}> destination) => units.Mul<{typeName}>(multiplicator, destination);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static void Mul(this ICollection<{typeName}?> units,
double multiplicator, Span<{typeName}?> destination) => units.Mul<{typeName}>(multiplicator, destination);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static void Mul(this double multiplicator,
ICollection<{typeName}> units, Span<{typeName}> destination) => units.Mul<{typeName}>(multiplicator, destination);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static void Mul(this double multiplicator,
ICollection<{typeName}?> units, Span<{typeName}?> destination) => units.Mul<{typeName}>(multiplicator, destination);
// === IReadOnlyCollection<T> ===
[MethodImpl(MethodImplOptions.AggressiveInlining)]public static void Mul(this IReadOnlyCollection<{typeName}> units,
double multiplicator, Span<{typeName}> destination) => units.Mul<{typeName}>(multiplicator, destination);
@@ -734,12 +1206,6 @@ public static class {typeName}Extensions
public static {typeName} Max(this List<{typeName}> list) => AggregateUnitExtensions.Max(list);
public static {typeName} Min(this List<{typeName}> list) => AggregateUnitExtensions.Min(list);
// === ICollection<T> ===
public static {typeName} Sum(this ICollection<{typeName}> collection) => AggregateUnitExtensions.Sum(collection);
public static {typeName} Avg(this ICollection<{typeName}> collection) => AggregateUnitExtensions.Avg(collection);
public static {typeName} Max(this ICollection<{typeName}> collection) => AggregateUnitExtensions.Max(collection);
public static {typeName} Min(this ICollection<{typeName}> collection) => AggregateUnitExtensions.Min(collection);
// === IReadOnlyCollection<T> ===
public static {typeName} Sum(this IReadOnlyCollection<{typeName}> collection) => AggregateUnitExtensions.Sum(collection);
public static {typeName} Avg(this IReadOnlyCollection<{typeName}> collection) => AggregateUnitExtensions.Avg(collection);
@@ -770,12 +1236,6 @@ public static class {typeName}Extensions
public static {typeName} Max(this List<{typeName}?> list) => AggregateUnitExtensions.Max(list);
public static {typeName} Min(this List<{typeName}?> list) => AggregateUnitExtensions.Min(list);
// === ICollection<T> ===
public static {typeName} Sum(this ICollection<{typeName}?> collection) => AggregateUnitExtensions.Sum(collection);
public static {typeName} Avg(this ICollection<{typeName}?> collection) => AggregateUnitExtensions.Avg(collection);
public static {typeName} Max(this ICollection<{typeName}?> collection) => AggregateUnitExtensions.Max(collection);
public static {typeName} Min(this ICollection<{typeName}?> collection) => AggregateUnitExtensions.Min(collection);
// === IReadOnlyCollection<T> ===
public static {typeName} Sum(this IReadOnlyCollection<{typeName}?> collection) => AggregateUnitExtensions.Sum(collection);
public static {typeName} Avg(this IReadOnlyCollection<{typeName}?> collection) => AggregateUnitExtensions.Avg(collection);