QWERTYkez/QWERTYkez.Mensura
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d49374b482a743859435069e5fa655e7298cb972
QWERTYkez.Mensura/QWERTYkez.Mensura.Generator/ComplexUnitGenerator.cs

1704 lines
141 KiB
C#
Raw Normal View History

Tests
2026-06-09 16:45:22 +07:00
namespace G;
26,06,05
2026-06-05 12:13:35 +07:00
[Generator]
public class ComplexUnitGenerator : IIncrementalGenerator
{
private const string AttributeName = "ComplexUnitGenerator";
public void Initialize(IncrementalGeneratorInitializationContext context)
{
// 1. Генерируем определение атрибута
context.RegisterPostInitializationOutput(ctx =>
{
string attributeSource = @"
namespace QWERTYkez.Mensura
{
[System.AttributeUsage(System.AttributeTargets.Struct, AllowMultiple = false)]
Tests
2026-06-09 16:45:22 +07:00
internal sealed class ComplexUnitGeneratorAttribute : System.Attribute
26,06,05
2026-06-05 12:13:35 +07:00
{
public string TypeNameA { get; }
public string TypeNameB { get; }
public string TypeNameZ { get; }
public ComplexUnitGeneratorAttribute(string typeNameA, string typeNameB, string typeNameZ)
{
TypeNameA = typeNameA;
TypeNameB = typeNameB;
TypeNameZ = typeNameZ;
}
}
}";
ctx.AddSource(".ComplexUnitGeneratorAttribute.g.cs", SourceText.From(attributeSource, Encoding.UTF8));
});
// 2. Ищем все readonly partial record struct с этим атрибутом
var structsProvider = context.SyntaxProvider
.CreateSyntaxProvider(
predicate: static (node, _) => IsTargetStruct(node),
transform: static (ctx, _) => GetStructInfo(ctx))
.Where(info => info.HasValue)
.Select((info, _) => info!.Value)
.Collect();
// 3. Регистрируем вывод для каждой найденной структуры
context.RegisterSourceOutput(structsProvider, (spc, structs) =>
{
Tests
2026-06-09 16:45:22 +07:00
// Ваш оригинальный цикл генерации комплексных структур
26,06,05
2026-06-05 12:13:35 +07:00
foreach (var structInfo in structs)
{
string generatedCode = GeneratePartial(structInfo.TypeName, structInfo.Namespace,
structInfo.TypeNameA, structInfo.TypeNameB, structInfo.TypeNameZ);
spc.AddSource($"{structInfo.TypeName}.g.cs", SourceText.From(generatedCode, Encoding.UTF8));
}
Tests
2026-06-09 16:45:22 +07:00
// --- ТОТ САМЫЙ КОД УСЛОВНОЙ ГЕНЕРАЦИИ БИНДЕРА ---
bool isMainAssembly = false;
var firstStruct = structs.FirstOrDefault();
if (firstStruct.TypeNameZ != null)
{
// Если пространство имен содержит "Tests", флаг останется false
if (firstStruct.Namespace.StartsWith("QWERTYkez.Mensura") && !firstStruct.Namespace.Contains("Tests"))
{
isMainAssembly = true;
}
}
// Генерируем файл ТОЛЬКО для основного проекта
if (isMainAssembly)
{
var sb = new StringBuilder();
sb.AppendLine("namespace QWERTYkez.Mensura;");
sb.AppendLine("internal static partial class MensuraBinder");
sb.AppendLine("{");
sb.AppendLine(" [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]");
sb.AppendLine(" static partial void AddGeneratedComplexConverters(System.Collections.IList converters)");
sb.AppendLine(" {");
foreach (var structInfo in structs)
{
sb.AppendLine($" converters.Add(new QWERTYkez.Mensura.MensuraBinder.NewtonsoftRegistrar.NewtonsoftUnitConverter<QWERTYkez.Mensura.Units.{structInfo.TypeNameZ}>());");
}
sb.AppendLine(" }");
sb.AppendLine("}");
spc.AddSource(".ComplexUnits.MensuraBinder.g.cs", SourceText.From(sb.ToString(), Encoding.UTF8));
EFcoreExtension
2026-06-13 20:25:29 +07:00
sb = new StringBuilder();
sb.AppendLine("using Microsoft.EntityFrameworkCore;");
sb.AppendLine("namespace QWERTYkez.Mensura.Extensions;");
sb.AppendLine("public static partial class EFCoreExtension");
sb.AppendLine("{");
sb.AppendLine(" [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining)]");
sb.AppendLine(" internal static void AddGeneratedComplexConverters(ModelConfigurationBuilder configurationBuilder)");
sb.AppendLine(" {");
foreach (var structInfo in structs)
{
sb.AppendLine($" configurationBuilder.Properties<{structInfo.TypeName}>().HaveConversion<MensuraUnitConverter<{structInfo.TypeName}>>();");
}
sb.AppendLine(" }");
sb.AppendLine("}");
spc.AddSource(".ComplexUnits.EFCoreExtension.g.cs", SourceText.From(sb.ToString(), Encoding.UTF8));
Tests
2026-06-09 16:45:22 +07:00
}
26,06,05
2026-06-05 12:13:35 +07:00
});
}
private static bool IsTargetStruct(SyntaxNode node)
{
if (node is not RecordDeclarationSyntax record)
return false;
// Должен быть record struct с модификаторами readonly и partial
if (!record.Modifiers.Any(SyntaxKind.ReadOnlyKeyword) ||
!record.Modifiers.Any(SyntaxKind.PartialKeyword) ||
!record.Keyword.IsKind(SyntaxKind.RecordKeyword) ||
!record.ClassOrStructKeyword.IsKind(SyntaxKind.StructKeyword))
return false;
// Проверяем наличие атрибута [ComplexUnitGenerator] или [ComplexUnitGeneratorAttribute]
foreach (var attrList in record.AttributeLists)
foreach (var attr in attrList.Attributes)
{
string name = attr.Name.ToString();
if (name == AttributeName || name == AttributeName + "Attribute")
return true;
}
return false;
}
private static StructInfo? GetStructInfo(GeneratorSyntaxContext context)
{
var record = (RecordDeclarationSyntax)context.Node;
var semanticModel = context.SemanticModel;
if (semanticModel.GetDeclaredSymbol(record) is not INamedTypeSymbol typeSymbol)
return null;
string namespaceName = typeSymbol.ContainingNamespace?.ToString() ?? "";
if (string.IsNullOrEmpty(namespaceName))
return null;
// Извлекаем аргументы атрибута
string typeNameA = null;
string typeNameB = null;
string typeNameZ = null;
foreach (var attrList in record.AttributeLists)
foreach (var attr in attrList.Attributes)
{
string name = attr.Name.ToString();
if (name == AttributeName || name == AttributeName + "Attribute")
{
// Ищем аргументы конструктора
var args = attr.ArgumentList?.Arguments;
if (args.HasValue && args.Value.Count >= 3)
{
typeNameA = GetStringFromExpression(args.Value[0].Expression, semanticModel);
typeNameB = GetStringFromExpression(args.Value[1].Expression, semanticModel);
typeNameZ = GetStringFromExpression(args.Value[2].Expression, semanticModel);
}
break;
}
}
if (typeNameA == null || typeNameB == null || typeNameZ == null)
return null;
return new StructInfo(namespaceName, typeSymbol.Name, typeNameA, typeNameB, typeNameZ);
}
private static string GetStringFromExpression(ExpressionSyntax expr, SemanticModel semanticModel)
{
// Поддерживаем строковые литералы и константы
if (expr is LiteralExpressionSyntax literal && literal.IsKind(SyntaxKind.StringLiteralExpression))
return literal.Token.ValueText;
// Если это доступ к константе, пытаемся вычислить через семантику
var constantValue = semanticModel.GetConstantValue(expr);
if (constantValue.HasValue && constantValue.Value is string s)
return s;
return null;
}
private static string GeneratePartial(string typeName, string ns, string typeNameA, string typeNameB, string typeNameZ)
{
// Шаблон, который вы вставите сами.
// В нём используйте {typeName}, {ns}, {typeNameA}, {typeNameB}, {typeNameZ}
// Например:
string template = @"
Fulll
2026-06-07 15:54:53 +07:00
global using {typeNameZ}Extensions = QWERTYkez.Mensura.Units.{typeNameZ}Extensions;
global using {typeNameZ} = QWERTYkez.Mensura.Units.{typeNameZ};
26,06,05
2026-06-05 12:13:35 +07:00
using System.Globalization;
using System.Runtime.Serialization;
Fulll
2026-06-07 15:54:53 +07:00
namespace QWERTYkez.Mensura.Units;
Tests
2026-06-09 16:45:22 +07:00
[JsonConverter(typeof(UnitJsonConverter<{typeNameZ}>))]
public IMensuraUnit
2026-06-15 09:00:43 +07:00
public readonly partial record struct {typeNameZ} : IEquatable<{typeNameZ}>, IMensuraUnit
26,06,05
2026-06-05 12:13:35 +07:00
{
26.06.08
2026-06-08 12:00:10 +07:00
[JsonInclude, DataMember, JsonPropertyName(""v""), Obsolete] // для JSON / EF на случай сбоев, если пробелма с _Value
internal double Value { get => _Value; init => _Value = value; }
internal readonly double _Value;
internal {typeNameZ}(double value) => _Value = value;
[NotMapped, JsonIgnore, IgnoreDataMember] internal {typeNameA} PerValue
{ get => ({typeNameA})_Value; init => _Value = (double)value; }
public static explicit operator {typeNameZ}(double val) => Unsafe.As<double, {typeNameZ}>(ref val);
public static explicit operator double({typeNameZ} unit) => unit._Value;
[JsonIgnore, IgnoreDataMember] public bool IsPositive => _Value >= 0;
[JsonIgnore, IgnoreDataMember] public bool IsGreaterThanZero => _Value > 0;
[JsonIgnore, IgnoreDataMember] public bool IsNegative => double.IsNegative(_Value);
[JsonIgnore, IgnoreDataMember] public bool IsZero => _Value == 0;
[JsonIgnore, IgnoreDataMember] public bool IsNaN => double.IsNaN(_Value);
[JsonIgnore, IgnoreDataMember] public bool IsFinite => double.IsFinite(_Value);
[JsonIgnore, IgnoreDataMember] public bool IsInfinity => double.IsInfinity(_Value);
[JsonIgnore, IgnoreDataMember] public bool IsPositiveInfinity => double.IsPositiveInfinity(_Value);
[JsonIgnore, IgnoreDataMember] public bool IsNegativeInfinity => double.IsNegativeInfinity(_Value);
WrapAsList debug
2026-06-10 16:05:42 +07:00
public static {typeNameZ} Zero { get; } = new(0d);
public static {typeNameZ} Min { get; } = new(double.MinValue);
public static {typeNameZ} Max { get; } = new(double.MaxValue);
public static {typeNameZ} NegativeInfinity { get; } = new(double.NegativeInfinity);
public static {typeNameZ} PositiveInfinity { get; } = new(double.PositiveInfinity);
tests
2026-06-11 15:42:01 +07:00
public static bool operator ==({typeNameZ}? T1, {typeNameZ}? T2) => T1.Protected() == T2.Protected();
public static bool operator !=({typeNameZ}? T1, {typeNameZ}? T2) => T1.Protected() != T2.Protected();
WrapAsList debug
2026-06-10 16:05:42 +07:00
tests
2026-06-11 15:42:01 +07:00
public static bool operator <({typeNameZ}? T1, {typeNameZ}? T2) => T1.Protected() < T2.Protected();
public static bool operator <=({typeNameZ}? T1, {typeNameZ}? T2) => T1.Protected() <= T2.Protected();
public static bool operator >({typeNameZ}? T1, {typeNameZ}? T2) => T1.Protected() > T2.Protected();
public static bool operator >=({typeNameZ}? T1, {typeNameZ}? T2) => T1.Protected() >= T2.Protected();
WrapAsList debug
2026-06-10 16:05:42 +07:00
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ} operator +({typeNameZ} T2) => new(+T2._Value);
public static {typeNameZ} operator +({typeNameZ} T1, {typeNameZ} T2) => new(T1._Value + T2._Value);
public static {typeNameZ} operator -({typeNameZ} T2) => new(-T2._Value);
public static {typeNameZ} operator -({typeNameZ} T1, {typeNameZ} T2) => new(T1._Value - T2._Value);
WrapAsList debug
2026-06-10 16:05:42 +07:00
// double
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ} operator *({typeNameZ} T1, double T2) => new(T1._Value * T2);
public static {typeNameZ} operator *({typeNameZ} T1, double? T2) => T1 * (T2 ?? 0d);
public static {typeNameZ} operator *(double T1, {typeNameZ} T2) => new(T1 * T2._Value);
public static {typeNameZ} operator *(double? T1, {typeNameZ} T2) => (T1 ?? 0d) * T2;
public static {typeNameZ} operator /({typeNameZ} T1, double T2) => new(T1._Value / T2);
public static {typeNameZ} operator /({typeNameZ} T1, double? T2) => T1 / (T2 ?? 0d);
public static double operator /({typeNameZ} T1, {typeNameZ} T2) => T1._Value / T2._Value;
WrapAsList debug
2026-06-10 16:05:42 +07:00
// sbyte
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ} operator *({typeNameZ} T1, sbyte T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *({typeNameZ} T1, sbyte? T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *(sbyte T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator *(sbyte? T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator /({typeNameZ} T1, sbyte T2) => T1 / T2.ToDouble();
public static {typeNameZ} operator /({typeNameZ} T1, sbyte? T2) => T1 / T2.ToDouble();
WrapAsList debug
2026-06-10 16:05:42 +07:00
// short
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ} operator *({typeNameZ} T1, short T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *({typeNameZ} T1, short? T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *(short T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator *(short? T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator /({typeNameZ} T1, short T2) => T1 / T2.ToDouble();
public static {typeNameZ} operator /({typeNameZ} T1, short? T2) => T1 / T2.ToDouble();
WrapAsList debug
2026-06-10 16:05:42 +07:00
// int
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ} operator *({typeNameZ} T1, int T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *({typeNameZ} T1, int? T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *(int T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator *(int? T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator /({typeNameZ} T1, int T2) => T1 / T2.ToDouble();
public static {typeNameZ} operator /({typeNameZ} T1, int? T2) => T1 / T2.ToDouble();
WrapAsList debug
2026-06-10 16:05:42 +07:00
// long
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ} operator *({typeNameZ} T1, long T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *({typeNameZ} T1, long? T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *(long T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator *(long? T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator /({typeNameZ} T1, long T2) => T1 / T2.ToDouble();
public static {typeNameZ} operator /({typeNameZ} T1, long? T2) => T1 / T2.ToDouble();
WrapAsList debug
2026-06-10 16:05:42 +07:00
// byte
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ} operator *({typeNameZ} T1, byte T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *({typeNameZ} T1, byte? T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *(byte T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator *(byte? T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator /({typeNameZ} T1, byte T2) => T1 / T2.ToDouble();
public static {typeNameZ} operator /({typeNameZ} T1, byte? T2) => T1 / T2.ToDouble();
WrapAsList debug
2026-06-10 16:05:42 +07:00
// ushort
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ} operator *({typeNameZ} T1, ushort T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *({typeNameZ} T1, ushort? T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *(ushort T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator *(ushort? T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator /({typeNameZ} T1, ushort T2) => T1 / T2.ToDouble();
public static {typeNameZ} operator /({typeNameZ} T1, ushort? T2) => T1 / T2.ToDouble();
WrapAsList debug
2026-06-10 16:05:42 +07:00
// uint
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ} operator *({typeNameZ} T1, uint T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *({typeNameZ} T1, uint? T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *(uint T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator *(uint? T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator /({typeNameZ} T1, uint T2) => T1 / T2.ToDouble();
public static {typeNameZ} operator /({typeNameZ} T1, uint? T2) => T1 / T2.ToDouble();
WrapAsList debug
2026-06-10 16:05:42 +07:00
// ulong
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ} operator *({typeNameZ} T1, ulong T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *({typeNameZ} T1, ulong? T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *(ulong T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator *(ulong? T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator /({typeNameZ} T1, ulong T2) => T1 / T2.ToDouble();
public static {typeNameZ} operator /({typeNameZ} T1, ulong? T2) => T1 / T2.ToDouble();
WrapAsList debug
2026-06-10 16:05:42 +07:00
// nint
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ} operator *({typeNameZ} T1, nint T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *({typeNameZ} T1, nint? T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *(nint T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator *(nint? T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator /({typeNameZ} T1, nint T2) => T1 / T2.ToDouble();
public static {typeNameZ} operator /({typeNameZ} T1, nint? T2) => T1 / T2.ToDouble();
WrapAsList debug
2026-06-10 16:05:42 +07:00
// nuint
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ} operator *({typeNameZ} T1, nuint T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *({typeNameZ} T1, nuint? T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *(nuint T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator *(nuint? T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator /({typeNameZ} T1, nuint T2) => T1 / T2.ToDouble();
public static {typeNameZ} operator /({typeNameZ} T1, nuint? T2) => T1 / T2.ToDouble();
WrapAsList debug
2026-06-10 16:05:42 +07:00
// Half
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ} operator *({typeNameZ} T1, Half T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *({typeNameZ} T1, Half? T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *(Half T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator *(Half? T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator /({typeNameZ} T1, Half T2) => T1 / T2.ToDouble();
public static {typeNameZ} operator /({typeNameZ} T1, Half? T2) => T1 / T2.ToDouble();
WrapAsList debug
2026-06-10 16:05:42 +07:00
// float
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ} operator *({typeNameZ} T1, float T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *({typeNameZ} T1, float? T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *(float T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator *(float? T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator /({typeNameZ} T1, float T2) => T1 / T2.ToDouble();
public static {typeNameZ} operator /({typeNameZ} T1, float? T2) => T1 / T2.ToDouble();
WrapAsList debug
2026-06-10 16:05:42 +07:00
// decimal
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ} operator *({typeNameZ} T1, decimal T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *({typeNameZ} T1, decimal? T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *(decimal T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator *(decimal? T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator /({typeNameZ} T1, decimal T2) => T1 / T2.ToDouble();
public static {typeNameZ} operator /({typeNameZ} T1, decimal? T2) => T1 / T2.ToDouble();
WrapAsList debug
2026-06-10 16:05:42 +07:00
#if NET7_0_OR_GREATER
// Int128
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ} operator *({typeNameZ} T1, Int128 T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *({typeNameZ} T1, Int128? T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *(Int128 T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator *(Int128? T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator /({typeNameZ} T1, Int128 T2) => T1 / T2.ToDouble();
public static {typeNameZ} operator /({typeNameZ} T1, Int128? T2) => T1 / T2.ToDouble();
WrapAsList debug
2026-06-10 16:05:42 +07:00
// UInt128
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ} operator *({typeNameZ} T1, UInt128 T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *({typeNameZ} T1, UInt128? T2) => T1 * T2.ToDouble();
public static {typeNameZ} operator *(UInt128 T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator *(UInt128? T1, {typeNameZ} T2) => T1.ToDouble() * T2;
public static {typeNameZ} operator /({typeNameZ} T1, UInt128 T2) => T1 / T2.ToDouble();
public static {typeNameZ} operator /({typeNameZ} T1, UInt128? T2) => T1 / T2.ToDouble();
WrapAsList debug
2026-06-10 16:05:42 +07:00
#endif
26.06.08
2026-06-08 12:00:10 +07:00
public static {typeNameA} operator *({typeNameZ} left, {typeNameB} right) => new(left._Value * right._Value);
public static {typeNameA} operator *({typeNameZ}? left, {typeNameB} right) => new(left.Protected() * right._Value);
public static {typeNameA} operator *({typeNameZ} left, {typeNameB}? right) => new(left._Value * right.Protected());
public static {typeNameA} operator *({typeNameZ}? left, {typeNameB}? right) => new(left.Protected() * right.Protected());
public static {typeNameA} operator *({typeNameB} left, {typeNameZ} right) => new(right._Value * left._Value);
public static {typeNameA} operator *({typeNameB}? left, {typeNameZ} right) => new(right._Value * left.Protected());
public static {typeNameA} operator *({typeNameB} left, {typeNameZ}? right) => new(right.Protected() * left._Value);
public static {typeNameA} operator *({typeNameB}? left, {typeNameZ}? right) => new(right.Protected() * left.Protected());
public static {typeNameB} operator /({typeNameA} left, {typeNameZ} right) => new(left._Value / right._Value);
public static {typeNameB} operator /({typeNameA}? left, {typeNameZ} right) => new(left.Protected() / right._Value);
public static {typeNameB} operator /({typeNameA} left, {typeNameZ}? right) => new(left._Value / right.Protected());
public static {typeNameB} operator /({typeNameA}? left, {typeNameZ}? right) => new(left.Protected() / right.Protected());
Fulll
2026-06-07 15:54:53 +07:00
// === Array ===
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameA}[] operator
Tests
2026-06-09 16:45:22 +07:00
*({typeNameB}[] units, {typeNameZ} multiplicator) => units.Mul<{typeNameB}, {typeNameA}>(multiplicator._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameA}?[] operator
Tests
2026-06-09 16:45:22 +07:00
*({typeNameB}?[] units, {typeNameZ} multiplicator) => units.Mul<{typeNameB}, {typeNameA}>(multiplicator._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameA}[] operator
Tests
2026-06-09 16:45:22 +07:00
*({typeNameZ} multiplicator, {typeNameB}[] units) => units.Mul<{typeNameB}, {typeNameA}>(multiplicator._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameA}?[] operator
Tests
2026-06-09 16:45:22 +07:00
*({typeNameZ} multiplicator, {typeNameB}?[] units) => units.Mul<{typeNameB}, {typeNameA}>(multiplicator._Value);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameA}[] operator *({typeNameB}[] units, {typeNameZ}? multiplicator) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : new {typeNameA}[units.Length]);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameA}?[] operator *({typeNameB}?[] units, {typeNameZ}? multiplicator) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : new {typeNameA}?[units.Length]);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameA}[] operator *({typeNameZ}? multiplicator, {typeNameB}[] units) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : new {typeNameA}[units.Length]);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameA}?[] operator *({typeNameZ}? multiplicator, {typeNameB}?[] units) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : new {typeNameA}?[units.Length]);
// === List<T> ===
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameA}> operator
Tests
2026-06-09 16:45:22 +07:00
*(List<{typeNameB}> units, {typeNameZ} multiplicator) => units.Mul<{typeNameB}, {typeNameA}>(multiplicator._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameA}?> operator
Tests
2026-06-09 16:45:22 +07:00
*(List<{typeNameB}?> units, {typeNameZ} multiplicator) => units.Mul<{typeNameB}, {typeNameA}>(multiplicator._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameA}> operator
Tests
2026-06-09 16:45:22 +07:00
*({typeNameZ} multiplicator, List<{typeNameB}> units) => units.Mul<{typeNameB}, {typeNameA}>(multiplicator._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameA}?> operator
Tests
2026-06-09 16:45:22 +07:00
*({typeNameZ} multiplicator, List<{typeNameB}?> units) => units.Mul<{typeNameB}, {typeNameA}>(multiplicator._Value);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameA}> operator *(List<{typeNameB}> units, {typeNameZ}? multiplicator) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : new List<{typeNameA}>(units.Count));
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameA}?> operator *(List<{typeNameB}?> units, {typeNameZ}? multiplicator) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : new List<{typeNameA}?>(units.Count));
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameA}> operator *({typeNameZ}? multiplicator, List<{typeNameB}> units) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : new List<{typeNameA}>(units.Count));
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameA}?> operator *({typeNameZ}? multiplicator, List<{typeNameB}?> units) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : new List<{typeNameA}?>(units.Count));
// === IEnumerable<T> ===
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameA}> operator
Tests
2026-06-09 16:45:22 +07:00
*(IEnumerable<{typeNameB}> units, {typeNameZ} multiplicator) => units.Mul<{typeNameB}, {typeNameA}>(multiplicator._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameA}?> operator
Tests
2026-06-09 16:45:22 +07:00
*(IEnumerable<{typeNameB}?> units, {typeNameZ} multiplicator) => units.Mul<{typeNameB}, {typeNameA}>(multiplicator._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameA}> operator
Tests
2026-06-09 16:45:22 +07:00
*({typeNameZ} multiplicator, IEnumerable<{typeNameB}> units) => units.Mul<{typeNameB}, {typeNameA}>(multiplicator._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameA}?> operator
Tests
2026-06-09 16:45:22 +07:00
*({typeNameZ} multiplicator, IEnumerable<{typeNameB}?> units) => units.Mul<{typeNameB}, {typeNameA}>(multiplicator._Value);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameA}> operator *(IEnumerable<{typeNameB}> units, {typeNameZ}? multiplicator) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : units.Select(u => new {typeNameA}(0d)));
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameA}?> operator *(IEnumerable<{typeNameB}?> units, {typeNameZ}? multiplicator) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : units.Select(u => u is null ? ({typeNameA}?)null : new {typeNameA}(0d)));
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameA}> operator *({typeNameZ}? multiplicator, IEnumerable<{typeNameB}> units) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : units.Select(u => new {typeNameA}(0d)));
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameA}?> operator *({typeNameZ}? multiplicator, IEnumerable<{typeNameB}?> units) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : units.Select(u => u is null ? ({typeNameA}?)null : new {typeNameA}(0d)));
// === Array ===
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameB}[] operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameA}[] units, {typeNameZ} divisor) => units.Div<{typeNameA}, {typeNameB}>(divisor._Value);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameB}?[] operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameA}?[] units, {typeNameZ} divisor) => units.Div<{typeNameA}, {typeNameB}>(divisor._Value);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameB}[] operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameZ} dividend, {typeNameA}[] units) => dividend._Value.Div<{typeNameA}, {typeNameB}>(units);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameB}?[] operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameZ} dividend, {typeNameA}?[] units) => dividend._Value.Div<{typeNameA}, {typeNameB}>(units);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameB}[] operator /({typeNameA}[] units, {typeNameZ}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : new {typeNameB}[units.Length]);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameB}?[] operator /({typeNameA}?[] units, {typeNameZ}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : new {typeNameB}?[units.Length]);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameB}[] operator /({typeNameZ}? dividend, {typeNameA}[] units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : new {typeNameB}[units.Length]);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameB}?[] operator /({typeNameZ}? dividend, {typeNameA}?[] units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : new {typeNameB}?[units.Length]);
Fulll
2026-06-07 15:54:53 +07:00
// === List<T> ===
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameB}> operator
Tests
2026-06-09 16:45:22 +07:00
/(List<{typeNameA}> units, {typeNameZ} divisor) => units.Div<{typeNameA}, {typeNameB}>(divisor._Value);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameB}?> operator
Tests
2026-06-09 16:45:22 +07:00
/(List<{typeNameA}?> units, {typeNameZ} divisor) => units.Div<{typeNameA}, {typeNameB}>(divisor._Value);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameB}> operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameZ} dividend, List<{typeNameA}> units) => dividend._Value.Div<{typeNameA}, {typeNameB}>(units);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameB}?> operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameZ} dividend, List<{typeNameA}?> units) => dividend._Value.Div<{typeNameA}, {typeNameB}>(units);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameB}> operator /(List<{typeNameA}> units, {typeNameZ}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : new List<{typeNameB}>(units.Count));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameB}?> operator /(List<{typeNameA}?> units, {typeNameZ}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : new List<{typeNameB}?>(units.Count));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameB}> operator /({typeNameZ}? dividend, List<{typeNameA}> units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : new List<{typeNameB}>(units.Count));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameB}?> operator /({typeNameZ}? dividend, List<{typeNameA}?> units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : new List<{typeNameB}?>(units.Count));
Fulll
2026-06-07 15:54:53 +07:00
// === IEnumerable<T> ===
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameB}> operator
Tests
2026-06-09 16:45:22 +07:00
/(IEnumerable<{typeNameA}> units, {typeNameZ} divisor) => units.Div<{typeNameA}, {typeNameB}>(divisor._Value);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameB}?> operator
Tests
2026-06-09 16:45:22 +07:00
/(IEnumerable<{typeNameA}?> units, {typeNameZ} divisor) => units.Div<{typeNameA}, {typeNameB}>(divisor._Value);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameB}> operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameZ} dividend, IEnumerable<{typeNameA}> units) => dividend._Value.Div<{typeNameA}, {typeNameB}>(units);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameB}?> operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameZ} dividend, IEnumerable<{typeNameA}?> units) => dividend._Value.Div<{typeNameA}, {typeNameB}>(units);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameB}> operator /(IEnumerable<{typeNameA}> units, {typeNameZ}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : units.Select(u => new {typeNameB}(0d)));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameB}?> operator /(IEnumerable<{typeNameA}?> units, {typeNameZ}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : units.Select(u => u is null ? ({typeNameB}?)null : new {typeNameB}(0d)));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameB}> operator /({typeNameZ}? dividend, IEnumerable<{typeNameA}> units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : units.Select(u => new {typeNameB}(0d)));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameB}?> operator /({typeNameZ}? dividend, IEnumerable<{typeNameA}?> units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : units.Select(u => u is null ? ({typeNameB}?)null : new {typeNameB}(0d)));
WrapAsList debug
2026-06-10 16:05:42 +07:00
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ}[] operator +({typeNameZ}[] T1, {typeNameZ} T2) => T1.Plus(T2._Value);
public static {typeNameZ}?[] operator +({typeNameZ}?[] T1, {typeNameZ} T2) => T1.Plus(T2._Value);
public static {typeNameZ}[] operator +({typeNameZ} T1, {typeNameZ}[] T2) => T1._Value.Plus(T2);
public static {typeNameZ}?[] operator +({typeNameZ} T1, {typeNameZ}?[] T2) => T1._Value.Plus(T2);
public static {typeNameZ}[] operator +({typeNameZ}[] T1, {typeNameZ}? T2) => T1.Plus(T2.Protected());
public static {typeNameZ}?[] operator +({typeNameZ}?[] T1, {typeNameZ}? T2) => T1.Plus(T2.Protected());
public static {typeNameZ}[] operator +({typeNameZ}? T1, {typeNameZ}[] T2) => T1.Protected().Plus(T2);
public static {typeNameZ}?[] operator +({typeNameZ}? T1, {typeNameZ}?[] T2) => T1.Protected().Plus(T2);
WrapAsList debug
2026-06-10 16:05:42 +07:00
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ}[] operator -({typeNameZ}[] T1, {typeNameZ} T2) => T1.Minus(T2._Value);
public static {typeNameZ}?[] operator -({typeNameZ}?[] T1, {typeNameZ} T2) => T1.Minus(T2._Value);
public static {typeNameZ}[] operator -({typeNameZ} T1, {typeNameZ}[] T2) => T1._Value.Minus(T2);
public static {typeNameZ}?[] operator -({typeNameZ} T1, {typeNameZ}?[] T2) => T1._Value.Minus(T2);
public static {typeNameZ}[] operator -({typeNameZ}[] T1, {typeNameZ}? T2) => T1.Minus(T2.Protected());
public static {typeNameZ}?[] operator -({typeNameZ}?[] T1, {typeNameZ}? T2) => T1.Minus(T2.Protected());
public static {typeNameZ}[] operator -({typeNameZ}? T1, {typeNameZ}[] T2) => T1.Protected().Minus(T2);
public static {typeNameZ}?[] operator -({typeNameZ}? T1, {typeNameZ}?[] T2) => T1.Protected().Minus(T2);
WrapAsList debug
2026-06-10 16:05:42 +07:00
tests
2026-06-11 15:42:01 +07:00
public static double[] operator /({typeNameZ} T1, {typeNameZ}[] T2) => T1.Div(T2);
public static double?[] operator /({typeNameZ} T1, {typeNameZ}?[] T2) => T1.Div(T2);
public static double[] operator /({typeNameZ}[] T1, {typeNameZ} T2) => T1.Div(T2);
public static double?[] operator /({typeNameZ}?[] T1, {typeNameZ} T2) => T1.Div(T2);
public static double[] operator /({typeNameZ}? T1, {typeNameZ}[] T2) => T1.ProtectedU().Div(T2);
public static double?[] operator /({typeNameZ}? T1, {typeNameZ}?[] T2) => T1.ProtectedU().Div(T2);
public static double[] operator /({typeNameZ}[] T1, {typeNameZ}? T2) => T1.Div(T2.ProtectedU());
public static double?[] operator /({typeNameZ}?[] T1, {typeNameZ}? T2) => T1.Div(T2.ProtectedU());
WrapAsList debug
2026-06-10 16:05:42 +07:00
// double
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ}[] operator *({typeNameZ} T1, double[] T2) => T1.Mul(T2);
public static {typeNameZ}?[] operator *({typeNameZ} T1, double?[] T2) => T1.Mul(T2);
public static {typeNameZ}[] operator *({typeNameZ}? T1, double[] T2) => T1.ProtectedU().Mul(T2);
public static {typeNameZ}?[] operator *({typeNameZ}? T1, double?[] T2) => T1.ProtectedU().Mul(T2);
public static {typeNameZ}[] operator *(double[] T1, {typeNameZ} T2) => T1.Mul(T2);
public static {typeNameZ}?[] operator *(double?[] T1, {typeNameZ} T2) => T1.Mul(T2);
public static {typeNameZ}[] operator *(double[] T1, {typeNameZ}? T2) => T1.Mul(T2.ProtectedU());
public static {typeNameZ}?[] operator *(double?[] T1, {typeNameZ}? T2) => T1.Mul(T2.ProtectedU());
public static {typeNameZ}[] operator /({typeNameZ} T1, double[] T2) => T1.Div(T2);
public static {typeNameZ}?[] operator /({typeNameZ} T1, double?[] T2) => T1.Div(T2);
public static {typeNameZ}[] operator /({typeNameZ}? T1, double[] T2) => T1.ProtectedU().Div(T2);
public static {typeNameZ}?[] operator /({typeNameZ}? T1, double?[] T2) => T1.ProtectedU().Div(T2);
WrapAsList debug
2026-06-10 16:05:42 +07:00
// sbyte
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ}[] operator *({typeNameZ} T1, sbyte[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ} T1, sbyte?[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}[] operator *({typeNameZ}? T1, sbyte[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ}? T1, sbyte?[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}[] operator *(sbyte[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}?[] operator *(sbyte?[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}[] operator *(sbyte[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}?[] operator *(sbyte?[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}[] operator /({typeNameZ} T1, sbyte[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ} T1, sbyte?[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}[] operator /({typeNameZ}? T1, sbyte[] T2) => T1.ProtectedU().Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ}? T1, sbyte?[] T2) => T1.ProtectedU().Div(T2.ToDouble());
WrapAsList debug
2026-06-10 16:05:42 +07:00
// short
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ}[] operator *({typeNameZ} T1, short[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ} T1, short?[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}[] operator *({typeNameZ}? T1, short[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ}? T1, short?[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}[] operator *(short[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}?[] operator *(short?[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}[] operator *(short[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}?[] operator *(short?[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}[] operator /({typeNameZ} T1, short[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ} T1, short?[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}[] operator /({typeNameZ}? T1, short[] T2) => T1.ProtectedU().Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ}? T1, short?[] T2) => T1.ProtectedU().Div(T2.ToDouble());
WrapAsList debug
2026-06-10 16:05:42 +07:00
// int
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ}[] operator *({typeNameZ} T1, int[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ} T1, int?[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}[] operator *({typeNameZ}? T1, int[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ}? T1, int?[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}[] operator *(int[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}?[] operator *(int?[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}[] operator *(int[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}?[] operator *(int?[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}[] operator /({typeNameZ} T1, int[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ} T1, int?[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}[] operator /({typeNameZ}? T1, int[] T2) => T1.ProtectedU().Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ}? T1, int?[] T2) => T1.ProtectedU().Div(T2.ToDouble());
WrapAsList debug
2026-06-10 16:05:42 +07:00
// long
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ}[] operator *({typeNameZ} T1, long[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ} T1, long?[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}[] operator *({typeNameZ}? T1, long[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ}? T1, long?[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}[] operator *(long[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}?[] operator *(long?[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}[] operator *(long[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}?[] operator *(long?[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}[] operator /({typeNameZ} T1, long[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ} T1, long?[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}[] operator /({typeNameZ}? T1, long[] T2) => T1.ProtectedU().Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ}? T1, long?[] T2) => T1.ProtectedU().Div(T2.ToDouble());
WrapAsList debug
2026-06-10 16:05:42 +07:00
// byte
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ}[] operator *({typeNameZ} T1, byte[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ} T1, byte?[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}[] operator *({typeNameZ}? T1, byte[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ}? T1, byte?[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}[] operator *(byte[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}?[] operator *(byte?[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}[] operator *(byte[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}?[] operator *(byte?[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}[] operator /({typeNameZ} T1, byte[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ} T1, byte?[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}[] operator /({typeNameZ}? T1, byte[] T2) => T1.ProtectedU().Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ}? T1, byte?[] T2) => T1.ProtectedU().Div(T2.ToDouble());
WrapAsList debug
2026-06-10 16:05:42 +07:00
// ushort
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ}[] operator *({typeNameZ} T1, ushort[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ} T1, ushort?[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}[] operator *({typeNameZ}? T1, ushort[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ}? T1, ushort?[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}[] operator *(ushort[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}?[] operator *(ushort?[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}[] operator *(ushort[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}?[] operator *(ushort?[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}[] operator /({typeNameZ} T1, ushort[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ} T1, ushort?[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}[] operator /({typeNameZ}? T1, ushort[] T2) => T1.ProtectedU().Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ}? T1, ushort?[] T2) => T1.ProtectedU().Div(T2.ToDouble());
WrapAsList debug
2026-06-10 16:05:42 +07:00
// uint
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ}[] operator *({typeNameZ} T1, uint[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ} T1, uint?[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}[] operator *({typeNameZ}? T1, uint[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ}? T1, uint?[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}[] operator *(uint[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}?[] operator *(uint?[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}[] operator *(uint[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}?[] operator *(uint?[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}[] operator /({typeNameZ} T1, uint[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ} T1, uint?[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}[] operator /({typeNameZ}? T1, uint[] T2) => T1.ProtectedU().Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ}? T1, uint?[] T2) => T1.ProtectedU().Div(T2.ToDouble());
WrapAsList debug
2026-06-10 16:05:42 +07:00
// ulong
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ}[] operator *({typeNameZ} T1, ulong[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ} T1, ulong?[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}[] operator *({typeNameZ}? T1, ulong[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ}? T1, ulong?[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}[] operator *(ulong[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}?[] operator *(ulong?[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}[] operator *(ulong[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}?[] operator *(ulong?[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}[] operator /({typeNameZ} T1, ulong[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ} T1, ulong?[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}[] operator /({typeNameZ}? T1, ulong[] T2) => T1.ProtectedU().Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ}? T1, ulong?[] T2) => T1.ProtectedU().Div(T2.ToDouble());
WrapAsList debug
2026-06-10 16:05:42 +07:00
// nint
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ}[] operator *({typeNameZ} T1, nint[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ} T1, nint?[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}[] operator *({typeNameZ}? T1, nint[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ}? T1, nint?[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}[] operator *(nint[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}?[] operator *(nint?[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}[] operator *(nint[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}?[] operator *(nint?[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}[] operator /({typeNameZ} T1, nint[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ} T1, nint?[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}[] operator /({typeNameZ}? T1, nint[] T2) => T1.ProtectedU().Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ}? T1, nint?[] T2) => T1.ProtectedU().Div(T2.ToDouble());
WrapAsList debug
2026-06-10 16:05:42 +07:00
// nuint
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ}[] operator *({typeNameZ} T1, nuint[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ} T1, nuint?[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}[] operator *({typeNameZ}? T1, nuint[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ}? T1, nuint?[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}[] operator *(nuint[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}?[] operator *(nuint?[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}[] operator *(nuint[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}?[] operator *(nuint?[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}[] operator /({typeNameZ} T1, nuint[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ} T1, nuint?[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}[] operator /({typeNameZ}? T1, nuint[] T2) => T1.ProtectedU().Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ}? T1, nuint?[] T2) => T1.ProtectedU().Div(T2.ToDouble());
WrapAsList debug
2026-06-10 16:05:42 +07:00
// Half
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ}[] operator *({typeNameZ} T1, Half[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ} T1, Half?[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}[] operator *({typeNameZ}? T1, Half[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ}? T1, Half?[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}[] operator *(Half[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}?[] operator *(Half?[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}[] operator *(Half[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}?[] operator *(Half?[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}[] operator /({typeNameZ} T1, Half[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ} T1, Half?[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}[] operator /({typeNameZ}? T1, Half[] T2) => T1.ProtectedU().Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ}? T1, Half?[] T2) => T1.ProtectedU().Div(T2.ToDouble());
WrapAsList debug
2026-06-10 16:05:42 +07:00
// float
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ}[] operator *({typeNameZ} T1, float[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ} T1, float?[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}[] operator *({typeNameZ}? T1, float[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ}? T1, float?[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}[] operator *(float[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}?[] operator *(float?[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}[] operator *(float[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}?[] operator *(float?[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}[] operator /({typeNameZ} T1, float[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ} T1, float?[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}[] operator /({typeNameZ}? T1, float[] T2) => T1.ProtectedU().Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ}? T1, float?[] T2) => T1.ProtectedU().Div(T2.ToDouble());
WrapAsList debug
2026-06-10 16:05:42 +07:00
// decimal
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ}[] operator *({typeNameZ} T1, decimal[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ} T1, decimal?[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}[] operator *({typeNameZ}? T1, decimal[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ}? T1, decimal?[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}[] operator *(decimal[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}?[] operator *(decimal?[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}[] operator *(decimal[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}?[] operator *(decimal?[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}[] operator /({typeNameZ} T1, decimal[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ} T1, decimal?[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}[] operator /({typeNameZ}? T1, decimal[] T2) => T1.ProtectedU().Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ}? T1, decimal?[] T2) => T1.ProtectedU().Div(T2.ToDouble());
WrapAsList debug
2026-06-10 16:05:42 +07:00
#if NET7_0_OR_GREATER
// Int128
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ}[] operator *({typeNameZ} T1, Int128[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ} T1, Int128?[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}[] operator *({typeNameZ}? T1, Int128[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ}? T1, Int128?[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}[] operator *(Int128[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}?[] operator *(Int128?[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}[] operator *(Int128[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}?[] operator *(Int128?[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}[] operator /({typeNameZ} T1, Int128[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ} T1, Int128?[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}[] operator /({typeNameZ}? T1, Int128[] T2) => T1.ProtectedU().Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ}? T1, Int128?[] T2) => T1.ProtectedU().Div(T2.ToDouble());
WrapAsList debug
2026-06-10 16:05:42 +07:00
// UInt128
tests
2026-06-11 15:42:01 +07:00
public static {typeNameZ}[] operator *({typeNameZ} T1, UInt128[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ} T1, UInt128?[] T2) => T1.Mul(T2.ToDouble());
public static {typeNameZ}[] operator *({typeNameZ}? T1, UInt128[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}?[] operator *({typeNameZ}? T1, UInt128?[] T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static {typeNameZ}[] operator *(UInt128[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}?[] operator *(UInt128?[] T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static {typeNameZ}[] operator *(UInt128[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}?[] operator *(UInt128?[] T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static {typeNameZ}[] operator /({typeNameZ} T1, UInt128[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ} T1, UInt128?[] T2) => T1.Div(T2.ToDouble());
public static {typeNameZ}[] operator /({typeNameZ}? T1, UInt128[] T2) => T1.ProtectedU().Div(T2.ToDouble());
public static {typeNameZ}?[] operator /({typeNameZ}? T1, UInt128?[] T2) => T1.ProtectedU().Div(T2.ToDouble());
#endif
public static List<{typeNameZ}> operator +(List<{typeNameZ}> T1, {typeNameZ} T2) => T1.Plus(T2._Value);
public static List<{typeNameZ}?> operator +(List<{typeNameZ}?> T1, {typeNameZ} T2) => T1.Plus(T2._Value);
public static List<{typeNameZ}> operator +({typeNameZ} T1, List<{typeNameZ}> T2) => T1._Value.Plus(T2);
public static List<{typeNameZ}?> operator +({typeNameZ} T1, List<{typeNameZ}?> T2) => T1._Value.Plus(T2);
public static List<{typeNameZ}> operator +(List<{typeNameZ}> T1, {typeNameZ}? T2) => T1.Plus(T2.Protected());
public static List<{typeNameZ}?> operator +(List<{typeNameZ}?> T1, {typeNameZ}? T2) => T1.Plus(T2.Protected());
public static List<{typeNameZ}> operator +({typeNameZ}? T1, List<{typeNameZ}> T2) => T1.Protected().Plus(T2);
public static List<{typeNameZ}?> operator +({typeNameZ}? T1, List<{typeNameZ}?> T2) => T1.Protected().Plus(T2);
public static List<{typeNameZ}> operator -(List<{typeNameZ}> T1, {typeNameZ} T2) => T1.Minus(T2._Value);
public static List<{typeNameZ}?> operator -(List<{typeNameZ}?> T1, {typeNameZ} T2) => T1.Minus(T2._Value);
public static List<{typeNameZ}> operator -({typeNameZ} T1, List<{typeNameZ}> T2) => T1._Value.Minus(T2);
public static List<{typeNameZ}?> operator -({typeNameZ} T1, List<{typeNameZ}?> T2) => T1._Value.Minus(T2);
public static List<{typeNameZ}> operator -(List<{typeNameZ}> T1, {typeNameZ}? T2) => T1.Minus(T2.Protected());
public static List<{typeNameZ}?> operator -(List<{typeNameZ}?> T1, {typeNameZ}? T2) => T1.Minus(T2.Protected());
public static List<{typeNameZ}> operator -({typeNameZ}? T1, List<{typeNameZ}> T2) => T1.Protected().Minus(T2);
public static List<{typeNameZ}?> operator -({typeNameZ}? T1, List<{typeNameZ}?> T2) => T1.Protected().Minus(T2);
public static List<double> operator /({typeNameZ} T1, List<{typeNameZ}> T2) => T1.Div(T2);
public static List<double?> operator /({typeNameZ} T1, List<{typeNameZ}?> T2) => T1.Div(T2);
public static List<double> operator /(List<{typeNameZ}> T1, {typeNameZ} T2) => T1.Div(T2);
public static List<double?> operator /(List<{typeNameZ}?> T1, {typeNameZ} T2) => T1.Div(T2);
public static List<double> operator /({typeNameZ}? T1, List<{typeNameZ}> T2) => T1.ProtectedU().Div(T2);
public static List<double?> operator /({typeNameZ}? T1, List<{typeNameZ}?> T2) => T1.ProtectedU().Div(T2);
public static List<double> operator /(List<{typeNameZ}> T1, {typeNameZ}? T2) => T1.Div(T2.ProtectedU());
public static List<double?> operator /(List<{typeNameZ}?> T1, {typeNameZ}? T2) => T1.Div(T2.ProtectedU());
// double
public static List<{typeNameZ}> operator *({typeNameZ} T1, List<double> T2) => T1.Mul(T2);
public static List<{typeNameZ}?> operator *({typeNameZ} T1, List<double?> T2) => T1.Mul(T2);
public static List<{typeNameZ}> operator *({typeNameZ}? T1, List<double> T2) => T1.ProtectedU().Mul(T2);
public static List<{typeNameZ}?> operator *({typeNameZ}? T1, List<double?> T2) => T1.ProtectedU().Mul(T2);
public static List<{typeNameZ}> operator *(List<double> T1, {typeNameZ} T2) => T1.Mul(T2);
public static List<{typeNameZ}?> operator *(List<double?> T1, {typeNameZ} T2) => T1.Mul(T2);
public static List<{typeNameZ}> operator *(List<double> T1, {typeNameZ}? T2) => T1.Mul(T2.ProtectedU());
public static List<{typeNameZ}?> operator *(List<double?> T1, {typeNameZ}? T2) => T1.Mul(T2.ProtectedU());
public static List<{typeNameZ}> operator /({typeNameZ} T1, List<double> T2) => T1.Div(T2);
public static List<{typeNameZ}?> operator /({typeNameZ} T1, List<double?> T2) => T1.Div(T2);
public static List<{typeNameZ}> operator /({typeNameZ}? T1, List<double> T2) => T1.ProtectedU().Div(T2);
public static List<{typeNameZ}?> operator /({typeNameZ}? T1, List<double?> T2) => T1.ProtectedU().Div(T2);
// sbyte
public static List<{typeNameZ}> operator *({typeNameZ} T1, List<sbyte> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ} T1, List<sbyte?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *({typeNameZ}? T1, List<sbyte> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ}? T1, List<sbyte?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *(List<sbyte> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}?> operator *(List<sbyte?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}> operator *(List<sbyte> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}?> operator *(List<sbyte?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}> operator /({typeNameZ} T1, List<sbyte> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ} T1, List<sbyte?> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}> operator /({typeNameZ}? T1, List<sbyte> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ}? T1, List<sbyte?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// short
public static List<{typeNameZ}> operator *({typeNameZ} T1, List<short> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ} T1, List<short?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *({typeNameZ}? T1, List<short> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ}? T1, List<short?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *(List<short> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}?> operator *(List<short?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}> operator *(List<short> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}?> operator *(List<short?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}> operator /({typeNameZ} T1, List<short> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ} T1, List<short?> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}> operator /({typeNameZ}? T1, List<short> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ}? T1, List<short?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// int
public static List<{typeNameZ}> operator *({typeNameZ} T1, List<int> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ} T1, List<int?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *({typeNameZ}? T1, List<int> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ}? T1, List<int?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *(List<int> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}?> operator *(List<int?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}> operator *(List<int> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}?> operator *(List<int?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}> operator /({typeNameZ} T1, List<int> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ} T1, List<int?> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}> operator /({typeNameZ}? T1, List<int> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ}? T1, List<int?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// long
public static List<{typeNameZ}> operator *({typeNameZ} T1, List<long> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ} T1, List<long?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *({typeNameZ}? T1, List<long> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ}? T1, List<long?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *(List<long> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}?> operator *(List<long?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}> operator *(List<long> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}?> operator *(List<long?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}> operator /({typeNameZ} T1, List<long> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ} T1, List<long?> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}> operator /({typeNameZ}? T1, List<long> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ}? T1, List<long?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// byte
public static List<{typeNameZ}> operator *({typeNameZ} T1, List<byte> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ} T1, List<byte?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *({typeNameZ}? T1, List<byte> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ}? T1, List<byte?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *(List<byte> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}?> operator *(List<byte?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}> operator *(List<byte> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}?> operator *(List<byte?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}> operator /({typeNameZ} T1, List<byte> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ} T1, List<byte?> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}> operator /({typeNameZ}? T1, List<byte> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ}? T1, List<byte?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// ushort
public static List<{typeNameZ}> operator *({typeNameZ} T1, List<ushort> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ} T1, List<ushort?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *({typeNameZ}? T1, List<ushort> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ}? T1, List<ushort?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *(List<ushort> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}?> operator *(List<ushort?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}> operator *(List<ushort> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}?> operator *(List<ushort?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}> operator /({typeNameZ} T1, List<ushort> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ} T1, List<ushort?> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}> operator /({typeNameZ}? T1, List<ushort> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ}? T1, List<ushort?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// uint
public static List<{typeNameZ}> operator *({typeNameZ} T1, List<uint> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ} T1, List<uint?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *({typeNameZ}? T1, List<uint> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ}? T1, List<uint?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *(List<uint> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}?> operator *(List<uint?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}> operator *(List<uint> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}?> operator *(List<uint?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}> operator /({typeNameZ} T1, List<uint> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ} T1, List<uint?> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}> operator /({typeNameZ}? T1, List<uint> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ}? T1, List<uint?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// ulong
public static List<{typeNameZ}> operator *({typeNameZ} T1, List<ulong> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ} T1, List<ulong?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *({typeNameZ}? T1, List<ulong> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ}? T1, List<ulong?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *(List<ulong> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}?> operator *(List<ulong?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}> operator *(List<ulong> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}?> operator *(List<ulong?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}> operator /({typeNameZ} T1, List<ulong> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ} T1, List<ulong?> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}> operator /({typeNameZ}? T1, List<ulong> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ}? T1, List<ulong?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// nint
public static List<{typeNameZ}> operator *({typeNameZ} T1, List<nint> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ} T1, List<nint?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *({typeNameZ}? T1, List<nint> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ}? T1, List<nint?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *(List<nint> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}?> operator *(List<nint?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}> operator *(List<nint> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}?> operator *(List<nint?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}> operator /({typeNameZ} T1, List<nint> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ} T1, List<nint?> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}> operator /({typeNameZ}? T1, List<nint> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ}? T1, List<nint?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// nuint
public static List<{typeNameZ}> operator *({typeNameZ} T1, List<nuint> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ} T1, List<nuint?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *({typeNameZ}? T1, List<nuint> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ}? T1, List<nuint?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *(List<nuint> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}?> operator *(List<nuint?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}> operator *(List<nuint> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}?> operator *(List<nuint?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}> operator /({typeNameZ} T1, List<nuint> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ} T1, List<nuint?> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}> operator /({typeNameZ}? T1, List<nuint> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ}? T1, List<nuint?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// float
public static List<{typeNameZ}> operator *({typeNameZ} T1, List<float> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ} T1, List<float?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *({typeNameZ}? T1, List<float> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ}? T1, List<float?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *(List<float> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}?> operator *(List<float?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}> operator *(List<float> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}?> operator *(List<float?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}> operator /({typeNameZ} T1, List<float> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ} T1, List<float?> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}> operator /({typeNameZ}? T1, List<float> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ}? T1, List<float?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// decimal
public static List<{typeNameZ}> operator *({typeNameZ} T1, List<decimal> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ} T1, List<decimal?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *({typeNameZ}? T1, List<decimal> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ}? T1, List<decimal?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *(List<decimal> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}?> operator *(List<decimal?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}> operator *(List<decimal> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}?> operator *(List<decimal?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}> operator /({typeNameZ} T1, List<decimal> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ} T1, List<decimal?> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}> operator /({typeNameZ}? T1, List<decimal> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ}? T1, List<decimal?> T2) => T1.ProtectedU().Div(T2.ToDouble());
#if NET7_0_OR_GREATER
// Int128
public static List<{typeNameZ}> operator *({typeNameZ} T1, List<Int128> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ} T1, List<Int128?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *({typeNameZ}? T1, List<Int128> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ}? T1, List<Int128?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *(List<Int128> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}?> operator *(List<Int128?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}> operator *(List<Int128> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}?> operator *(List<Int128?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}> operator /({typeNameZ} T1, List<Int128> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ} T1, List<Int128?> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}> operator /({typeNameZ}? T1, List<Int128> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ}? T1, List<Int128?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// UInt128
public static List<{typeNameZ}> operator *({typeNameZ} T1, List<UInt128> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ} T1, List<UInt128?> T2) => T1.Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *({typeNameZ}? T1, List<UInt128> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}?> operator *({typeNameZ}? T1, List<UInt128?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static List<{typeNameZ}> operator *(List<UInt128> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}?> operator *(List<UInt128?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static List<{typeNameZ}> operator *(List<UInt128> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}?> operator *(List<UInt128?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static List<{typeNameZ}> operator /({typeNameZ} T1, List<UInt128> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ} T1, List<UInt128?> T2) => T1.Div(T2.ToDouble());
public static List<{typeNameZ}> operator /({typeNameZ}? T1, List<UInt128> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static List<{typeNameZ}?> operator /({typeNameZ}? T1, List<UInt128?> T2) => T1.ProtectedU().Div(T2.ToDouble());
#endif
public static IEnumerable<{typeNameZ}> operator +(IEnumerable<{typeNameZ}> T1, {typeNameZ} T2) => T1.Plus(T2._Value);
public static IEnumerable<{typeNameZ}?> operator +(IEnumerable<{typeNameZ}?> T1, {typeNameZ} T2) => T1.Plus(T2._Value);
public static IEnumerable<{typeNameZ}> operator +({typeNameZ} T1, IEnumerable<{typeNameZ}> T2) => T1._Value.Plus(T2);
public static IEnumerable<{typeNameZ}?> operator +({typeNameZ} T1, IEnumerable<{typeNameZ}?> T2) => T1._Value.Plus(T2);
public static IEnumerable<{typeNameZ}> operator +(IEnumerable<{typeNameZ}> T1, {typeNameZ}? T2) => T1.Plus(T2.Protected());
public static IEnumerable<{typeNameZ}?> operator +(IEnumerable<{typeNameZ}?> T1, {typeNameZ}? T2) => T1.Plus(T2.Protected());
public static IEnumerable<{typeNameZ}> operator +({typeNameZ}? T1, IEnumerable<{typeNameZ}> T2) => T1.Protected().Plus(T2);
public static IEnumerable<{typeNameZ}?> operator +({typeNameZ}? T1, IEnumerable<{typeNameZ}?> T2) => T1.Protected().Plus(T2);
public static IEnumerable<{typeNameZ}> operator -(IEnumerable<{typeNameZ}> T1, {typeNameZ} T2) => T1.Minus(T2._Value);
public static IEnumerable<{typeNameZ}?> operator -(IEnumerable<{typeNameZ}?> T1, {typeNameZ} T2) => T1.Minus(T2._Value);
public static IEnumerable<{typeNameZ}> operator -({typeNameZ} T1, IEnumerable<{typeNameZ}> T2) => T1._Value.Minus(T2);
public static IEnumerable<{typeNameZ}?> operator -({typeNameZ} T1, IEnumerable<{typeNameZ}?> T2) => T1._Value.Minus(T2);
public static IEnumerable<{typeNameZ}> operator -(IEnumerable<{typeNameZ}> T1, {typeNameZ}? T2) => T1.Minus(T2.Protected());
public static IEnumerable<{typeNameZ}?> operator -(IEnumerable<{typeNameZ}?> T1, {typeNameZ}? T2) => T1.Minus(T2.Protected());
public static IEnumerable<{typeNameZ}> operator -({typeNameZ}? T1, IEnumerable<{typeNameZ}> T2) => T1.Protected().Minus(T2);
public static IEnumerable<{typeNameZ}?> operator -({typeNameZ}? T1, IEnumerable<{typeNameZ}?> T2) => T1.Protected().Minus(T2);
public static IEnumerable<double> operator /({typeNameZ} T1, IEnumerable<{typeNameZ}> T2) => T1.Div(T2);
public static IEnumerable<double?> operator /({typeNameZ} T1, IEnumerable<{typeNameZ}?> T2) => T1.Div(T2);
public static IEnumerable<double> operator /(IEnumerable<{typeNameZ}> T1, {typeNameZ} T2) => T1.Div(T2);
public static IEnumerable<double?> operator /(IEnumerable<{typeNameZ}?> T1, {typeNameZ} T2) => T1.Div(T2);
public static IEnumerable<double> operator /({typeNameZ}? T1, IEnumerable<{typeNameZ}> T2) => T1.ProtectedU().Div(T2);
public static IEnumerable<double?> operator /({typeNameZ}? T1, IEnumerable<{typeNameZ}?> T2) => T1.ProtectedU().Div(T2);
public static IEnumerable<double> operator /(IEnumerable<{typeNameZ}> T1, {typeNameZ}? T2) => T1.Div(T2.ProtectedU());
public static IEnumerable<double?> operator /(IEnumerable<{typeNameZ}?> T1, {typeNameZ}? T2) => T1.Div(T2.ProtectedU());
// double
public static IEnumerable<{typeNameZ}> operator *({typeNameZ} T1, IEnumerable<double> T2) => T1.Mul(T2);
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ} T1, IEnumerable<double?> T2) => T1.Mul(T2);
public static IEnumerable<{typeNameZ}> operator *({typeNameZ}? T1, IEnumerable<double> T2) => T1.ProtectedU().Mul(T2);
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ}? T1, IEnumerable<double?> T2) => T1.ProtectedU().Mul(T2);
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<double> T1, {typeNameZ} T2) => T1.Mul(T2);
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<double?> T1, {typeNameZ} T2) => T1.Mul(T2);
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<double> T1, {typeNameZ}? T2) => T1.Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<double?> T1, {typeNameZ}? T2) => T1.Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ} T1, IEnumerable<double> T2) => T1.Div(T2);
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ} T1, IEnumerable<double?> T2) => T1.Div(T2);
public static IEnumerable<{typeNameZ}> operator /({typeNameZ}? T1, IEnumerable<double> T2) => T1.ProtectedU().Div(T2);
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ}? T1, IEnumerable<double?> T2) => T1.ProtectedU().Div(T2);
// sbyte
public static IEnumerable<{typeNameZ}> operator *({typeNameZ} T1, IEnumerable<sbyte> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ} T1, IEnumerable<sbyte?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *({typeNameZ}? T1, IEnumerable<sbyte> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ}? T1, IEnumerable<sbyte?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<sbyte> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<sbyte?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<sbyte> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<sbyte?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ} T1, IEnumerable<sbyte> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ} T1, IEnumerable<sbyte?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ}? T1, IEnumerable<sbyte> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ}? T1, IEnumerable<sbyte?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// short
public static IEnumerable<{typeNameZ}> operator *({typeNameZ} T1, IEnumerable<short> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ} T1, IEnumerable<short?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *({typeNameZ}? T1, IEnumerable<short> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ}? T1, IEnumerable<short?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<short> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<short?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<short> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<short?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ} T1, IEnumerable<short> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ} T1, IEnumerable<short?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ}? T1, IEnumerable<short> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ}? T1, IEnumerable<short?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// int
public static IEnumerable<{typeNameZ}> operator *({typeNameZ} T1, IEnumerable<int> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ} T1, IEnumerable<int?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *({typeNameZ}? T1, IEnumerable<int> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ}? T1, IEnumerable<int?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<int> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<int?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<int> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<int?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ} T1, IEnumerable<int> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ} T1, IEnumerable<int?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ}? T1, IEnumerable<int> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ}? T1, IEnumerable<int?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// long
public static IEnumerable<{typeNameZ}> operator *({typeNameZ} T1, IEnumerable<long> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ} T1, IEnumerable<long?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *({typeNameZ}? T1, IEnumerable<long> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ}? T1, IEnumerable<long?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<long> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<long?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<long> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<long?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ} T1, IEnumerable<long> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ} T1, IEnumerable<long?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ}? T1, IEnumerable<long> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ}? T1, IEnumerable<long?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// byte
public static IEnumerable<{typeNameZ}> operator *({typeNameZ} T1, IEnumerable<byte> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ} T1, IEnumerable<byte?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *({typeNameZ}? T1, IEnumerable<byte> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ}? T1, IEnumerable<byte?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<byte> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<byte?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<byte> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<byte?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ} T1, IEnumerable<byte> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ} T1, IEnumerable<byte?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ}? T1, IEnumerable<byte> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ}? T1, IEnumerable<byte?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// ushort
public static IEnumerable<{typeNameZ}> operator *({typeNameZ} T1, IEnumerable<ushort> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ} T1, IEnumerable<ushort?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *({typeNameZ}? T1, IEnumerable<ushort> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ}? T1, IEnumerable<ushort?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<ushort> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<ushort?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<ushort> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<ushort?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ} T1, IEnumerable<ushort> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ} T1, IEnumerable<ushort?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ}? T1, IEnumerable<ushort> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ}? T1, IEnumerable<ushort?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// uint
public static IEnumerable<{typeNameZ}> operator *({typeNameZ} T1, IEnumerable<uint> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ} T1, IEnumerable<uint?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *({typeNameZ}? T1, IEnumerable<uint> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ}? T1, IEnumerable<uint?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<uint> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<uint?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<uint> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<uint?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ} T1, IEnumerable<uint> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ} T1, IEnumerable<uint?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ}? T1, IEnumerable<uint> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ}? T1, IEnumerable<uint?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// ulong
public static IEnumerable<{typeNameZ}> operator *({typeNameZ} T1, IEnumerable<ulong> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ} T1, IEnumerable<ulong?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *({typeNameZ}? T1, IEnumerable<ulong> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ}? T1, IEnumerable<ulong?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<ulong> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<ulong?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<ulong> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<ulong?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ} T1, IEnumerable<ulong> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ} T1, IEnumerable<ulong?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ}? T1, IEnumerable<ulong> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ}? T1, IEnumerable<ulong?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// nint
public static IEnumerable<{typeNameZ}> operator *({typeNameZ} T1, IEnumerable<nint> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ} T1, IEnumerable<nint?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *({typeNameZ}? T1, IEnumerable<nint> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ}? T1, IEnumerable<nint?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<nint> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<nint?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<nint> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<nint?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ} T1, IEnumerable<nint> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ} T1, IEnumerable<nint?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ}? T1, IEnumerable<nint> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ}? T1, IEnumerable<nint?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// nuint
public static IEnumerable<{typeNameZ}> operator *({typeNameZ} T1, IEnumerable<nuint> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ} T1, IEnumerable<nuint?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *({typeNameZ}? T1, IEnumerable<nuint> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ}? T1, IEnumerable<nuint?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<nuint> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<nuint?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<nuint> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<nuint?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ} T1, IEnumerable<nuint> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ} T1, IEnumerable<nuint?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ}? T1, IEnumerable<nuint> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ}? T1, IEnumerable<nuint?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// float
public static IEnumerable<{typeNameZ}> operator *({typeNameZ} T1, IEnumerable<float> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ} T1, IEnumerable<float?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *({typeNameZ}? T1, IEnumerable<float> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ}? T1, IEnumerable<float?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<float> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<float?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<float> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<float?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ} T1, IEnumerable<float> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ} T1, IEnumerable<float?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ}? T1, IEnumerable<float> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ}? T1, IEnumerable<float?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// decimal
public static IEnumerable<{typeNameZ}> operator *({typeNameZ} T1, IEnumerable<decimal> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ} T1, IEnumerable<decimal?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *({typeNameZ}? T1, IEnumerable<decimal> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ}? T1, IEnumerable<decimal?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<decimal> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<decimal?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<decimal> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<decimal?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ} T1, IEnumerable<decimal> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ} T1, IEnumerable<decimal?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ}? T1, IEnumerable<decimal> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ}? T1, IEnumerable<decimal?> T2) => T1.ProtectedU().Div(T2.ToDouble());
#if NET7_0_OR_GREATER
// Int128
public static IEnumerable<{typeNameZ}> operator *({typeNameZ} T1, IEnumerable<Int128> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ} T1, IEnumerable<Int128?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *({typeNameZ}? T1, IEnumerable<Int128> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ}? T1, IEnumerable<Int128?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<Int128> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<Int128?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<Int128> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<Int128?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ} T1, IEnumerable<Int128> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ} T1, IEnumerable<Int128?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ}? T1, IEnumerable<Int128> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ}? T1, IEnumerable<Int128?> T2) => T1.ProtectedU().Div(T2.ToDouble());
// UInt128
public static IEnumerable<{typeNameZ}> operator *({typeNameZ} T1, IEnumerable<UInt128> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ} T1, IEnumerable<UInt128?> T2) => T1.Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *({typeNameZ}? T1, IEnumerable<UInt128> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator *({typeNameZ}? T1, IEnumerable<UInt128?> T2) => T1.ProtectedU().Mul(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<UInt128> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<UInt128?> T1, {typeNameZ} T2) => T1.ToDouble().Mul(T2);
public static IEnumerable<{typeNameZ}> operator *(IEnumerable<UInt128> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}?> operator *(IEnumerable<UInt128?> T1, {typeNameZ}? T2) => T1.ToDouble().Mul(T2.ProtectedU());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ} T1, IEnumerable<UInt128> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ} T1, IEnumerable<UInt128?> T2) => T1.Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}> operator /({typeNameZ}? T1, IEnumerable<UInt128> T2) => T1.ProtectedU().Div(T2.ToDouble());
public static IEnumerable<{typeNameZ}?> operator /({typeNameZ}? T1, IEnumerable<UInt128?> T2) => T1.ProtectedU().Div(T2.ToDouble());
WrapAsList debug
2026-06-10 16:05:42 +07:00
#endif
Fulll
2026-06-07 15:54:53 +07:00
}
26.06.08
2026-06-08 12:00:10 +07:00
Tests
2026-06-09 16:45:22 +07:00
public static class {typeNameZ}Extensions
26.06.08
2026-06-08 12:00:10 +07:00
{
Tests
2026-06-09 16:45:22 +07:00
// === ReadOnlySpan
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static void Div(this ReadOnlySpan<{typeNameZ}> units,
double divisor, Span<{typeNameZ}> destination) => units.Div<{typeNameZ}>(divisor, destination);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static void Div(this ReadOnlySpan<{typeNameZ}?> units,
double divisor, Span<{typeNameZ}?> destination) => units.Div<{typeNameZ}>(divisor, destination);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static void Div(this double dividend,
ReadOnlySpan<{typeNameZ}> units, Span<{typeNameZ}> destination) => dividend.Div<{typeNameZ}>(units, destination);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static void Div(this double dividend,
ReadOnlySpan<{typeNameZ}?> units, Span<{typeNameZ}?> destination) => dividend.Div<{typeNameZ}>(units, destination);
// === Array ===
[MethodImpl(MethodImplOptions.AggressiveInlining)]public static {typeNameZ}[] Div(
this {typeNameZ}[] units, double divisor) => units.Div<{typeNameZ}>(divisor);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameZ}?[] Div(
this {typeNameZ}?[] units, double divisor) => units.Div<{typeNameZ}>(divisor);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameZ}[] Div(
this double dividend, {typeNameZ}[] units) => dividend.Div<{typeNameZ}>(units);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameZ}?[] Div(
this double dividend, {typeNameZ}?[] units) => dividend.Div<{typeNameZ}>(units);
// === List<T> ===
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}> Div(
this List<{typeNameZ}> units, double divisor) => units.Div<{typeNameZ}>(divisor);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}?> Div(
this List<{typeNameZ}?> units, double divisor) => units.Div<{typeNameZ}>(divisor);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}> Div(
this double dividend, List<{typeNameZ}> units) => dividend.Div<{typeNameZ}>(units);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}?> Div(
this double dividend, List<{typeNameZ}?> units) => dividend.Div<{typeNameZ}>(units);
// === IReadOnlyCollection<T> ===
[MethodImpl(MethodImplOptions.AggressiveInlining)]public static void Div(this IReadOnlyCollection<{typeNameZ}> units,
double divisor, Span<{typeNameZ}> destination) => units.Div<{typeNameZ}>(divisor, destination);
[MethodImpl(MethodImplOptions.AggressiveInlining)]public static void Div(this IReadOnlyCollection<{typeNameZ}?> units,
double divisor, Span<{typeNameZ}?> destination) => units.Div<{typeNameZ}>(divisor, destination);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static void Div(this double dividend,
IReadOnlyCollection<{typeNameZ}> units, Span<{typeNameZ}> destination) => dividend.Div<{typeNameZ}>(units, destination);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static void Div(this double dividend,
IReadOnlyCollection<{typeNameZ}?> units, Span<{typeNameZ}?> destination) => dividend.Div<{typeNameZ}>(units, destination);
// === IEnumerable<T> ===
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}> Div(
this IEnumerable<{typeNameZ}> units, double divisor) => units.Div<{typeNameZ}>(divisor);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}?> Div(
this IEnumerable<{typeNameZ}?> units, double divisor) => units.Div<{typeNameZ}>(divisor);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}> Div(
this double dividend, IEnumerable<{typeNameZ}> units) => dividend.Div<{typeNameZ}>(units);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}?> Div(
this double dividend, IEnumerable<{typeNameZ}?> units) => dividend.Div<{typeNameZ}>(units);
// === ReadOnlySpan
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static void Mul(this ReadOnlySpan<{typeNameZ}> units,
double multiplicator, Span<{typeNameZ}> destination) => units.Mul<{typeNameZ}>(multiplicator, destination);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static void Mul(this ReadOnlySpan<{typeNameZ}?> units,
double multiplicator, Span<{typeNameZ}?> destination) => units.Mul<{typeNameZ}>(multiplicator, destination);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static void Mul(this double multiplicator,
ReadOnlySpan<{typeNameZ}> units, Span<{typeNameZ}> destination) => units.Mul<{typeNameZ}>(multiplicator, destination);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static void Mul(this double multiplicator,
ReadOnlySpan<{typeNameZ}?> units, Span<{typeNameZ}?> destination) => units.Mul<{typeNameZ}>(multiplicator, destination);
// === Array ===
[MethodImpl(MethodImplOptions.AggressiveInlining)]public static {typeNameZ}[] Mul(
this {typeNameZ}[] units, double multiplicator) => units.Mul<{typeNameZ}>(multiplicator);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameZ}?[] Mul(
this {typeNameZ}?[] units, double multiplicator) => units.Mul<{typeNameZ}>(multiplicator);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameZ}[] Mul(
this double multiplicator, {typeNameZ}[] units) => units.Mul<{typeNameZ}>(multiplicator);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameZ}?[] Mul(
this double multiplicator, {typeNameZ}?[] units) => units.Mul<{typeNameZ}>(multiplicator);
// === List<T> ===
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}> Mul(
this List<{typeNameZ}> units, double multiplicator) => units.Mul<{typeNameZ}>(multiplicator);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}?> Mul(
this List<{typeNameZ}?> units, double multiplicator) => units.Mul<{typeNameZ}>(multiplicator);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}> Mul(
this double multiplicator, List<{typeNameZ}> units) => units.Mul<{typeNameZ}>(multiplicator);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}?> Mul(
this double multiplicator, List<{typeNameZ}?> units) => units.Mul<{typeNameZ}>(multiplicator);
// === IReadOnlyCollection<T> ===
[MethodImpl(MethodImplOptions.AggressiveInlining)]public static void Mul(this IReadOnlyCollection<{typeNameZ}> units,
double multiplicator, Span<{typeNameZ}> destination) => units.Mul<{typeNameZ}>(multiplicator, destination);
[MethodImpl(MethodImplOptions.AggressiveInlining)]public static void Mul(this IReadOnlyCollection<{typeNameZ}?> units,
double multiplicator, Span<{typeNameZ}?> destination) => units.Mul<{typeNameZ}>(multiplicator, destination);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static void Mul(this double multiplicator,
IReadOnlyCollection<{typeNameZ}> units, Span<{typeNameZ}> destination) => units.Mul<{typeNameZ}>(multiplicator, destination);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static void Mul(this double multiplicator,
IReadOnlyCollection<{typeNameZ}?> units, Span<{typeNameZ}?> destination) => units.Mul<{typeNameZ}>(multiplicator, destination);
// === IEnumerable<T> ===
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}> Mul(
this IEnumerable<{typeNameZ}> units, double multiplicator) => units.Mul<{typeNameZ}>(multiplicator);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}?> Mul(
this IEnumerable<{typeNameZ}?> units, double multiplicator) => units.Mul<{typeNameZ}>(multiplicator);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}> Mul(
this double multiplicator, IEnumerable<{typeNameZ}> units) => units.Mul<{typeNameZ}>(multiplicator);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}?> Mul(
this double multiplicator, IEnumerable<{typeNameZ}?> units) => units.Mul<{typeNameZ}>(multiplicator);
WrapAsList debug
2026-06-10 16:05:42 +07:00
// Sum Avg Max Min (не nullable) ==========================================
Tests
2026-06-09 16:45:22 +07:00
// === ReadOnlySpan === SIMD
public static {typeNameZ} Sum(this ReadOnlySpan<{typeNameZ}> units) => AggregateUnitExtensions.Sum(units);
WrapAsList debug
2026-06-10 16:05:42 +07:00
public static {typeNameZ} Avg(this ReadOnlySpan<{typeNameZ}> units) => AggregateUnitExtensions.Avg(units);
Tests
2026-06-09 16:45:22 +07:00
public static {typeNameZ} Max(this ReadOnlySpan<{typeNameZ}> units) => AggregateUnitExtensions.Max(units);
public static {typeNameZ} Min(this ReadOnlySpan<{typeNameZ}> units) => AggregateUnitExtensions.Min(units);
// === List<T> ===
public static {typeNameZ} Sum(this List<{typeNameZ}> list) => AggregateUnitExtensions.Sum(list);
WrapAsList debug
2026-06-10 16:05:42 +07:00
public static {typeNameZ} Avg(this List<{typeNameZ}> list) => AggregateUnitExtensions.Avg(list);
Tests
2026-06-09 16:45:22 +07:00
public static {typeNameZ} Max(this List<{typeNameZ}> list) => AggregateUnitExtensions.Max(list);
public static {typeNameZ} Min(this List<{typeNameZ}> list) => AggregateUnitExtensions.Min(list);
// === IReadOnlyCollection<T> ===
public static {typeNameZ} Sum(this IReadOnlyCollection<{typeNameZ}> collection) => AggregateUnitExtensions.Sum(collection);
WrapAsList debug
2026-06-10 16:05:42 +07:00
public static {typeNameZ} Avg(this IReadOnlyCollection<{typeNameZ}> collection) => AggregateUnitExtensions.Avg(collection);
Tests
2026-06-09 16:45:22 +07:00
public static {typeNameZ} Max(this IReadOnlyCollection<{typeNameZ}> collection) => AggregateUnitExtensions.Max(collection);
public static {typeNameZ} Min(this IReadOnlyCollection<{typeNameZ}> collection) => AggregateUnitExtensions.Min(collection);
// === IEnumerable<T> ===
public static {typeNameZ} Sum(this IEnumerable<{typeNameZ}> collection) => AggregateUnitExtensions.Sum(collection);
WrapAsList debug
2026-06-10 16:05:42 +07:00
public static {typeNameZ} Avg(this IEnumerable<{typeNameZ}> collection) => AggregateUnitExtensions.Avg(collection);
Tests
2026-06-09 16:45:22 +07:00
public static {typeNameZ} Max(this IEnumerable<{typeNameZ}> collection) => AggregateUnitExtensions.Max(collection);
public static {typeNameZ} Min(this IEnumerable<{typeNameZ}> collection) => AggregateUnitExtensions.Min(collection);
WrapAsList debug
2026-06-10 16:05:42 +07:00
// Sum Avg Max Min (nullable) ==========================================
Tests
2026-06-09 16:45:22 +07:00
// === ReadOnlySpan ===
public static {typeNameZ} Sum(this ReadOnlySpan<{typeNameZ}?> units) => AggregateUnitExtensions.Sum(units);
WrapAsList debug
2026-06-10 16:05:42 +07:00
public static {typeNameZ} Avg(this ReadOnlySpan<{typeNameZ}?> units) => AggregateUnitExtensions.Avg(units);
Tests
2026-06-09 16:45:22 +07:00
public static {typeNameZ} Max(this ReadOnlySpan<{typeNameZ}?> units) => AggregateUnitExtensions.Max(units);
public static {typeNameZ} Min(this ReadOnlySpan<{typeNameZ}?> units) => AggregateUnitExtensions.Min(units);
// === List<T> ===
public static {typeNameZ} Sum(this List<{typeNameZ}?> list) => AggregateUnitExtensions.Sum(list);
WrapAsList debug
2026-06-10 16:05:42 +07:00
public static {typeNameZ} Avg(this List<{typeNameZ}?> list) => AggregateUnitExtensions.Avg(list);
Tests
2026-06-09 16:45:22 +07:00
public static {typeNameZ} Max(this List<{typeNameZ}?> list) => AggregateUnitExtensions.Max(list);
public static {typeNameZ} Min(this List<{typeNameZ}?> list) => AggregateUnitExtensions.Min(list);
// === IReadOnlyCollection<T> ===
public static {typeNameZ} Sum(this IReadOnlyCollection<{typeNameZ}?> collection) => AggregateUnitExtensions.Sum(collection);
WrapAsList debug
2026-06-10 16:05:42 +07:00
public static {typeNameZ} Avg(this IReadOnlyCollection<{typeNameZ}?> collection) => AggregateUnitExtensions.Avg(collection);
Tests
2026-06-09 16:45:22 +07:00
public static {typeNameZ} Max(this IReadOnlyCollection<{typeNameZ}?> collection) => AggregateUnitExtensions.Max(collection);
public static {typeNameZ} Min(this IReadOnlyCollection<{typeNameZ}?> collection) => AggregateUnitExtensions.Min(collection);
// === IEnumerable<T> ===
public static {typeNameZ} Sum(this IEnumerable<{typeNameZ}?> collection) => AggregateUnitExtensions.Sum(collection);
WrapAsList debug
2026-06-10 16:05:42 +07:00
public static {typeNameZ} Avg(this IEnumerable<{typeNameZ}?> collection) => AggregateUnitExtensions.Avg(collection);
Tests
2026-06-09 16:45:22 +07:00
public static {typeNameZ} Max(this IEnumerable<{typeNameZ}?> collection) => AggregateUnitExtensions.Max(collection);
public static {typeNameZ} Min(this IEnumerable<{typeNameZ}?> collection) => AggregateUnitExtensions.Min(collection);
26.06.08
2026-06-08 12:00:10 +07:00
}
Fulll
2026-06-07 15:54:53 +07:00
public readonly partial record struct {typeNameA}
{
// === Array ===
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameB}[] operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameZ}[] units, {typeNameA} divisor) => units.Div<{typeNameZ}, {typeNameB}>(divisor._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameB}?[] operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameZ}?[] units, {typeNameA} divisor) => units.Div<{typeNameZ}, {typeNameB}>(divisor._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameB}[] operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameA} dividend, {typeNameZ}[] units) => dividend._Value.Div<{typeNameZ}, {typeNameB}>(units);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameB}?[] operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameA} dividend, {typeNameZ}?[] units) => dividend._Value.Div<{typeNameZ}, {typeNameB}>(units);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameB}[] operator /({typeNameZ}[] units, {typeNameA}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : new {typeNameB}[units.Length]);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameB}?[] operator /({typeNameZ}?[] units, {typeNameA}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : new {typeNameB}?[units.Length]);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameB}[] operator /({typeNameA}? dividend, {typeNameZ}[] units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : new {typeNameB}[units.Length]);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameB}?[] operator /({typeNameA}? dividend, {typeNameZ}?[] units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : new {typeNameB}?[units.Length]);
// === List<T> ===
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameB}> operator
Tests
2026-06-09 16:45:22 +07:00
/(List<{typeNameZ}> units, {typeNameA} divisor) => units.Div<{typeNameZ}, {typeNameB}>(divisor._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameB}?> operator
Tests
2026-06-09 16:45:22 +07:00
/(List<{typeNameZ}?> units, {typeNameA} divisor) => units.Div<{typeNameZ}, {typeNameB}>(divisor._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameB}> operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameA} dividend, List<{typeNameZ}> units) => dividend._Value.Div<{typeNameZ}, {typeNameB}>(units);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameB}?> operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameA} dividend, List<{typeNameZ}?> units) => dividend._Value.Div<{typeNameZ}, {typeNameB}>(units);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameB}> operator /(List<{typeNameZ}> units, {typeNameA}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : new List<{typeNameB}>(units.Count));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameB}?> operator /(List<{typeNameZ}?> units, {typeNameA}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : new List<{typeNameB}?>(units.Count));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameB}> operator /({typeNameA}? dividend, List<{typeNameZ}> units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : new List<{typeNameB}>(units.Count));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameB}?> operator /({typeNameA}? dividend, List<{typeNameZ}?> units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : new List<{typeNameB}?>(units.Count));
// === IEnumerable<T> ===
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameB}> operator
Tests
2026-06-09 16:45:22 +07:00
/(IEnumerable<{typeNameZ}> units, {typeNameA} divisor) => units.Div<{typeNameZ}, {typeNameB}>(divisor._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameB}?> operator
Tests
2026-06-09 16:45:22 +07:00
/(IEnumerable<{typeNameZ}?> units, {typeNameA} divisor) => units.Div<{typeNameZ}, {typeNameB}>(divisor._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameB}> operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameA} dividend, IEnumerable<{typeNameZ}> units) => dividend._Value.Div<{typeNameZ}, {typeNameB}>(units);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameB}?> operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameA} dividend, IEnumerable<{typeNameZ}?> units) => dividend._Value.Div<{typeNameZ}, {typeNameB}>(units);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameB}> operator /(IEnumerable<{typeNameZ}> units, {typeNameA}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : units.Select(u => new {typeNameB}(0d)));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameB}?> operator /(IEnumerable<{typeNameZ}?> units, {typeNameA}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : units.Select(u => u is null ? ({typeNameB}?)null : new {typeNameB}(0d)));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameB}> operator /({typeNameA}? dividend, IEnumerable<{typeNameZ}> units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : units.Select(u => new {typeNameB}(0d)));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameB}?> operator /({typeNameA}? dividend, IEnumerable<{typeNameZ}?> units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : units.Select(u => u is null ? ({typeNameB}?)null : new {typeNameB}(0d)));
// === Array ===
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameZ}[] operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameB}[] units, {typeNameA} divisor) => units.Div<{typeNameB}, {typeNameZ}>(divisor._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameZ}?[] operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameB}?[] units, {typeNameA} divisor) => units.Div<{typeNameB}, {typeNameZ}>(divisor._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameZ}[] operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameA} dividend, {typeNameB}[] units) => dividend._Value.Div<{typeNameB}, {typeNameZ}>(units);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameZ}?[] operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameA} dividend, {typeNameB}?[] units) => dividend._Value.Div<{typeNameB}, {typeNameZ}>(units);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameZ}[] operator /({typeNameB}[] units, {typeNameA}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : new {typeNameZ}[units.Length]);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameZ}?[] operator /({typeNameB}?[] units, {typeNameA}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : new {typeNameZ}?[units.Length]);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameZ}[] operator /({typeNameA}? dividend, {typeNameB}[] units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : new {typeNameZ}[units.Length]);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameZ}?[] operator /({typeNameA}? dividend, {typeNameB}?[] units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : new {typeNameZ}?[units.Length]);
// === List<T> ===
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}> operator
Tests
2026-06-09 16:45:22 +07:00
/(List<{typeNameB}> units, {typeNameA} divisor) => units.Div<{typeNameB}, {typeNameZ}>(divisor._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}?> operator
Tests
2026-06-09 16:45:22 +07:00
/(List<{typeNameB}?> units, {typeNameA} divisor) => units.Div<{typeNameB}, {typeNameZ}>(divisor._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}> operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameA} dividend, List<{typeNameB}> units) => dividend._Value.Div<{typeNameB}, {typeNameZ}>(units);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}?> operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameA} dividend, List<{typeNameB}?> units) => dividend._Value.Div<{typeNameB}, {typeNameZ}>(units);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}> operator /(List<{typeNameB}> units, {typeNameA}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : new List<{typeNameZ}>(units.Count));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}?> operator /(List<{typeNameB}?> units, {typeNameA}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : new List<{typeNameZ}?>(units.Count));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}> operator /({typeNameA}? dividend, List<{typeNameB}> units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : new List<{typeNameZ}>(units.Count));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}?> operator /({typeNameA}? dividend, List<{typeNameB}?> units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : new List<{typeNameZ}?>(units.Count));
// === IEnumerable<T> ===
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}> operator
Tests
2026-06-09 16:45:22 +07:00
/(IEnumerable<{typeNameB}> units, {typeNameA} divisor) => units.Div<{typeNameB}, {typeNameZ}>(divisor._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}?> operator
Tests
2026-06-09 16:45:22 +07:00
/(IEnumerable<{typeNameB}?> units, {typeNameA} divisor) => units.Div<{typeNameB}, {typeNameZ}>(divisor._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}> operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameA} dividend, IEnumerable<{typeNameB}> units) => dividend._Value.Div<{typeNameB}, {typeNameZ}>(units);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}?> operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameA} dividend, IEnumerable<{typeNameB}?> units) => dividend._Value.Div<{typeNameB}, {typeNameZ}>(units);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}> operator /(IEnumerable<{typeNameB}> units, {typeNameA}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : units.Select(u => new {typeNameZ}(0d)));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}?> operator /(IEnumerable<{typeNameB}?> units, {typeNameA}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : units.Select(u => u is null ? ({typeNameZ}?)null : new {typeNameZ}(0d)));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}> operator /({typeNameA}? dividend, IEnumerable<{typeNameB}> units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : units.Select(u => new {typeNameZ}(0d)));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}?> operator /({typeNameA}? dividend, IEnumerable<{typeNameB}?> units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : units.Select(u => u is null ? ({typeNameZ}?)null : new {typeNameZ}(0d)));
26,06,05
2026-06-05 12:13:35 +07:00
}
26.06.08
2026-06-08 12:00:10 +07:00
public readonly partial record struct {typeNameB}
26,06,05
2026-06-05 12:13:35 +07:00
{
26.06.08
2026-06-08 12:00:10 +07:00
public static {typeNameZ} operator /({typeNameA} left, {typeNameB} right) => new(left._Value / right._Value);
public static {typeNameZ} operator /({typeNameA}? left, {typeNameB} right) => new(left.Protected() / right._Value);
public static {typeNameZ} operator /({typeNameA} left, {typeNameB}? right) => new(left._Value / right.Protected());
public static {typeNameZ} operator /({typeNameA}? left, {typeNameB}? right) => new(left.Protected() / right.Protected());
Fulll
2026-06-07 15:54:53 +07:00
// === Array ===
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameA}[] operator
Tests
2026-06-09 16:45:22 +07:00
*({typeNameZ}[] units, {typeNameB} multiplicator) => units.Mul<{typeNameZ}, {typeNameA}>(multiplicator._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameA}?[] operator
Tests
2026-06-09 16:45:22 +07:00
*({typeNameZ}?[] units, {typeNameB} multiplicator) => units.Mul<{typeNameZ}, {typeNameA}>(multiplicator._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameA}[] operator
Tests
2026-06-09 16:45:22 +07:00
*({typeNameB} multiplicator, {typeNameZ}[] units) => units.Mul<{typeNameZ}, {typeNameA}>(multiplicator._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameA}?[] operator
Tests
2026-06-09 16:45:22 +07:00
*({typeNameB} multiplicator, {typeNameZ}?[] units) => units.Mul<{typeNameZ}, {typeNameA}>(multiplicator._Value);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameA}[] operator *({typeNameZ}[] units, {typeNameB}? multiplicator) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : new {typeNameA}[units.Length]);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameA}?[] operator *({typeNameZ}?[] units, {typeNameB}? multiplicator) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : new {typeNameA}?[units.Length]);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameA}[] operator *({typeNameB}? multiplicator, {typeNameZ}[] units) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : new {typeNameA}[units.Length]);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameA}?[] operator *({typeNameB}? multiplicator, {typeNameZ}?[] units) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : new {typeNameA}?[units.Length]);
// === List<T> ===
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameA}> operator
Tests
2026-06-09 16:45:22 +07:00
*(List<{typeNameZ}> units, {typeNameB} multiplicator) => units.Mul<{typeNameZ}, {typeNameA}>(multiplicator._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameA}?> operator
Tests
2026-06-09 16:45:22 +07:00
*(List<{typeNameZ}?> units, {typeNameB} multiplicator) => units.Mul<{typeNameZ}, {typeNameA}>(multiplicator._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameA}> operator
Tests
2026-06-09 16:45:22 +07:00
*({typeNameB} multiplicator, List<{typeNameZ}> units) => units.Mul<{typeNameZ}, {typeNameA}>(multiplicator._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameA}?> operator
Tests
2026-06-09 16:45:22 +07:00
*({typeNameB} multiplicator, List<{typeNameZ}?> units) => units.Mul<{typeNameZ}, {typeNameA}>(multiplicator._Value);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameA}> operator *(List<{typeNameZ}> units, {typeNameB}? multiplicator) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : new List<{typeNameA}>(units.Count));
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameA}?> operator *(List<{typeNameZ}?> units, {typeNameB}? multiplicator) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : new List<{typeNameA}?>(units.Count));
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameA}> operator *({typeNameB}? multiplicator, List<{typeNameZ}> units) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : new List<{typeNameA}>(units.Count));
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameA}?> operator *({typeNameB}? multiplicator, List<{typeNameZ}?> units) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : new List<{typeNameA}?>(units.Count));
// === IEnumerable<T> ===
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameA}> operator
Tests
2026-06-09 16:45:22 +07:00
*(IEnumerable<{typeNameZ}> units, {typeNameB} multiplicator) => units.Mul<{typeNameZ}, {typeNameA}>(multiplicator._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameA}?> operator
Tests
2026-06-09 16:45:22 +07:00
*(IEnumerable<{typeNameZ}?> units, {typeNameB} multiplicator) => units.Mul<{typeNameZ}, {typeNameA}>(multiplicator._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameA}> operator
Tests
2026-06-09 16:45:22 +07:00
*({typeNameB} multiplicator, IEnumerable<{typeNameZ}> units) => units.Mul<{typeNameZ}, {typeNameA}>(multiplicator._Value);
Fulll
2026-06-07 15:54:53 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameA}?> operator
Tests
2026-06-09 16:45:22 +07:00
*({typeNameB} multiplicator, IEnumerable<{typeNameZ}?> units) => units.Mul<{typeNameZ}, {typeNameA}>(multiplicator._Value);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameA}> operator *(IEnumerable<{typeNameZ}> units, {typeNameB}? multiplicator) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : units.Select(u => new {typeNameA}(0d)));
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameA}?> operator *(IEnumerable<{typeNameZ}?> units, {typeNameB}? multiplicator) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : units.Select(u => u is null ? ({typeNameA}?)null : new {typeNameA}(0d)));
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameA}> operator *({typeNameB}? multiplicator, IEnumerable<{typeNameZ}> units) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : units.Select(u => new {typeNameA}(0d)));
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameA}?> operator *({typeNameB}? multiplicator, IEnumerable<{typeNameZ}?> units) =>
Fulll
2026-06-07 15:54:53 +07:00
multiplicator.HasValue ? units * multiplicator.Value : (units is null ? null! : units.Select(u => u is null ? ({typeNameA}?)null : new {typeNameA}(0d)));
26.06.08
2026-06-08 12:00:10 +07:00
Fulll
2026-06-07 15:54:53 +07:00
// === Array ===
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameZ}[] operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameA}[] units, {typeNameB} divisor) => units.Div<{typeNameA}, {typeNameZ}>(divisor._Value);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameZ}?[] operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameA}?[] units, {typeNameB} divisor) => units.Div<{typeNameA}, {typeNameZ}>(divisor._Value);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameZ}[] operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameB} dividend, {typeNameA}[] units) => dividend._Value.Div<{typeNameA}, {typeNameZ}>(units);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameZ}?[] operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameB} dividend, {typeNameA}?[] units) => dividend._Value.Div<{typeNameA}, {typeNameZ}>(units);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameZ}[] operator /({typeNameA}[] units, {typeNameB}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : new {typeNameZ}[units.Length]);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameZ}?[] operator /({typeNameA}?[] units, {typeNameB}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : new {typeNameZ}?[units.Length]);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameZ}[] operator /({typeNameB}? dividend, {typeNameA}[] units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : new {typeNameZ}[units.Length]);
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static {typeNameZ}?[] operator /({typeNameB}? dividend, {typeNameA}?[] units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : new {typeNameZ}?[units.Length]);
Fulll
2026-06-07 15:54:53 +07:00
// === List<T> ===
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}> operator
Tests
2026-06-09 16:45:22 +07:00
/(List<{typeNameA}> units, {typeNameB} divisor) => units.Div<{typeNameA}, {typeNameZ}>(divisor._Value);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}?> operator
Tests
2026-06-09 16:45:22 +07:00
/(List<{typeNameA}?> units, {typeNameB} divisor) => units.Div<{typeNameA}, {typeNameZ}>(divisor._Value);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}> operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameB} dividend, List<{typeNameA}> units) => dividend._Value.Div<{typeNameA}, {typeNameZ}>(units);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}?> operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameB} dividend, List<{typeNameA}?> units) => dividend._Value.Div<{typeNameA}, {typeNameZ}>(units);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}> operator /(List<{typeNameA}> units, {typeNameB}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : new List<{typeNameZ}>(units.Count));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}?> operator /(List<{typeNameA}?> units, {typeNameB}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : new List<{typeNameZ}?>(units.Count));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}> operator /({typeNameB}? dividend, List<{typeNameA}> units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : new List<{typeNameZ}>(units.Count));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static List<{typeNameZ}?> operator /({typeNameB}? dividend, List<{typeNameA}?> units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : new List<{typeNameZ}?>(units.Count));
Fulll
2026-06-07 15:54:53 +07:00
// === IEnumerable<T> ===
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}> operator
Tests
2026-06-09 16:45:22 +07:00
/(IEnumerable<{typeNameA}> units, {typeNameB} divisor) => units.Div<{typeNameA}, {typeNameZ}>(divisor._Value);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}?> operator
Tests
2026-06-09 16:45:22 +07:00
/(IEnumerable<{typeNameA}?> units, {typeNameB} divisor) => units.Div<{typeNameA}, {typeNameZ}>(divisor._Value);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}> operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameB} dividend, IEnumerable<{typeNameA}> units) => dividend._Value.Div<{typeNameA}, {typeNameZ}>(units);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}?> operator
Tests
2026-06-09 16:45:22 +07:00
/({typeNameB} dividend, IEnumerable<{typeNameA}?> units) => dividend._Value.Div<{typeNameA}, {typeNameZ}>(units);
26.06.08
2026-06-08 12:00:10 +07:00
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}> operator /(IEnumerable<{typeNameA}> units, {typeNameB}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : units.Select(u => new {typeNameZ}(0d)));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}?> operator /(IEnumerable<{typeNameA}?> units, {typeNameB}? divisor) =>
divisor.HasValue ? units / divisor.Value : (units is null ? null! : units.Select(u => u is null ? ({typeNameZ}?)null : new {typeNameZ}(0d)));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}> operator /({typeNameB}? dividend, IEnumerable<{typeNameA}> units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : units.Select(u => new {typeNameZ}(0d)));
[MethodImpl(MethodImplOptions.AggressiveInlining)] public static IEnumerable<{typeNameZ}?> operator /({typeNameB}? dividend, IEnumerable<{typeNameA}?> units) =>
dividend.HasValue ? units / dividend.Value : (units is null ? null! : units.Select(u => u is null ? ({typeNameZ}?)null : new {typeNameZ}(0d)));
26,06,05
2026-06-05 12:13:35 +07:00
}
";
return template
.Replace("{ns}", ns)
.Replace("{typeName}", typeName)
.Replace("{typeNameA}", typeNameA)
.Replace("{typeNameB}", typeNameB)
.Replace("{typeNameZ}", typeNameZ);
}
private readonly struct StructInfo(string ns, string name, string a, string b, string z)
{
public string Namespace { get; } = ns;
public string TypeName { get; } = name;
public string TypeNameA { get; } = a;
public string TypeNameB { get; } = b;
public string TypeNameZ { get; } = z;
}
}
Reference in New Issue Copy Permalink