Fulll

QWERTYkez.Mensura.Generator/ComplexUnitGenerator.cs

@@ -141,15 +141,15 @@ namespace QWERTYkez.Mensura
         // В нём используйте {typeName}, {ns}, {typeNameA}, {typeNameB}, {typeNameZ}
         // Например:
         string template = @"
-global using {typeNameZ}Extensions = QWERTYkez.Mensura.Units.Complex.{typeNameZ}Extensions;
+global using {typeNameZ}Extensions = QWERTYkez.Mensura.Units.{typeNameZ}Extensions;
-global using {typeNameZ}Converter = QWERTYkez.Mensura.Units.Complex.{typeNameZ}Converter;
+global using {typeNameZ}Converter = QWERTYkez.Mensura.Units.{typeNameZ}Converter;
-global using {typeNameZ} = QWERTYkez.Mensura.Units.Complex.{typeNameZ};
+global using {typeNameZ} = QWERTYkez.Mensura.Units.{typeNameZ};
 
 using System.Globalization;
 using System.Runtime.Serialization;
 
-namespace QWERTYkez.Mensura.Units
+namespace QWERTYkez.Mensura.Units;
-{
+
 public readonly partial record struct {typeNameB}
 {
     public static {typeNameZ} operator /({typeNameA} left, {typeNameB} right) => new(left._Value / right._Value);
@@ -392,10 +392,7 @@ namespace QWERTYkez.Mensura.Units
     [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)));
 }
-}
 
-namespace QWERTYkez.Mensura.Units.Complex
-{
 [JsonConverter(typeof({typeNameZ}Converter))]
 public readonly partial record struct {typeNameZ} : IMensuraUnit<{typeNameZ}>, IEquatable<{typeNameZ}>, IMensuraUnit
 {
@@ -616,7 +613,6 @@ namespace QWERTYkez.Mensura.Units.Complex
         return new(double_Value);
     }
 }
-}
 ";
 
         return template

QWERTYkez.Mensura.Generator/OperatorsGenerator.cs

@@ -2,194 +2,208 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Text;
-using System.Collections.Immutable;
 using System.Linq;
 using System.Text;
 
-namespace G;
+namespace G
-
-[Generator(LanguageNames.CSharp)]
-public class CollectionsOperatorsGenerator : IIncrementalGenerator
 {
-    private const string AttributeShortName = "CollectionsOperatorsGenerator";
+    [Generator(LanguageNames.CSharp)]
-    private const string AttributeFullName = AttributeShortName + "Attribute";
+    public class OperatorsGenerator : IIncrementalGenerator
+    {
+        private const string AttributeSource = @"// <auto-generated />
+using System;
 
-    private const string AttributeSource = @"namespace QWERTYkez.Mensura;
+namespace QWERTYkez.Mensura
+{
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
+    public sealed class OperatorsGeneratorAttribute : Attribute
+    {
+        public string CoeffName { get; }
 
-[System.AttributeUsage(System.AttributeTargets.Struct | System.AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
+        public OperatorsGeneratorAttribute()
-internal sealed class CollectionsOperatorsGeneratorAttribute : System.Attribute { }";
+        {
+        }
 
-    // Какие типы коллекций поддерживаем
+        public OperatorsGeneratorAttribute(string coeffName)
-    private static readonly (string Type, string Selector)[] CollectionTypes =
+        {
-    [
+            CoeffName = coeffName;
-        ("T[]", "array => array.Select(u => left * u).ToArray()"), // но нужно адаптировать под конкретный тип
+        }
-        // Проще генерировать отдельные методы для каждого типа
+    }
-    ];
+}";
 
         public void Initialize(IncrementalGeneratorInitializationContext context)
         {
-        context.RegisterPostInitializationOutput(ctx =>
+            // 1. Внедряем атрибут
-            ctx.AddSource($"{AttributeFullName}.g", SourceText.From(AttributeSource, Encoding.UTF8)));
+            context.RegisterPostInitializationOutput(static postInitializationContext =>
-
-        var operatorsPipeline = context.SyntaxProvider
-            .CreateSyntaxProvider(
-                predicate: static (node, _) => IsTargetType(node),
-                transform: static (ctx, _) => GetTypeInfo(ctx))
-            .Where(info => info.HasValue) // использование nullable value type
-            .Select((info, _) => info!.Value)
-            .Collect();
-
-        context.RegisterSourceOutput(operatorsPipeline, GenerateOperators);
-    }
-
-    private static bool IsTargetType(SyntaxNode node)
             {
-        if (node is not TypeDeclarationSyntax typeDecl)
+                postInitializationContext.AddSource(
-            return false;
+                    ".OperatorsGeneratorAttribute.g.cs",
+                    SourceText.From(AttributeSource, Encoding.UTF8));
+            });
 
-        // Должен быть partial и не generic
+            // 2. Ищем методы-операторы, помеченные атрибутом
-        if (!typeDecl.Modifiers.Any(SyntaxKind.PartialKeyword))
+            IncrementalValuesProvider<OperatorInfo> operatorDeclarations = context.SyntaxProvider
-            return false;
+                .ForAttributeWithMetadataName(
-        if (typeDecl.TypeParameterList != null)
+                    fullyQualifiedMetadataName: "QWERTYkez.Mensura.OperatorsGeneratorAttribute",
-            return false;
+                    predicate: static (node, _) => node is OperatorDeclarationSyntax,
+                    transform: static (ctx, _) => GetSemanticTargetForGeneration(ctx))
+                .Where(static m => m is not null)!;
 
-        // Проверяем наличие атрибута на самом типе
+            // 3. Выполняем генерацию кода
-        foreach (var attrList in typeDecl.AttributeLists)
+            context.RegisterSourceOutput(operatorDeclarations, static (spc, opInfo) => Execute(spc, opInfo));
-            foreach (var attr in attrList.Attributes)
+        }
+
+        private static OperatorInfo GetSemanticTargetForGeneration(GeneratorAttributeSyntaxContext context)
         {
-                string name = attr.Name.ToString();
+            var opDeclaration = (OperatorDeclarationSyntax)context.TargetNode;
-                if (name == AttributeShortName || name == AttributeFullName)
-                    return true;
-            }
 
-        // Или на операторах внутри
+            if (opDeclaration.ParameterList.Parameters.Count < 2) return null;
-        foreach (var member in typeDecl.Members)
+
+            if (context.SemanticModel.GetDeclaredSymbol(opDeclaration) is not IMethodSymbol symbol) return null;
+
+            var namespaceName = symbol.ContainingNamespace.ToDisplayString();
+
+            var leftType = opDeclaration.ParameterList.Parameters[0].Type?.ToString() ?? "";
+            var rightType = opDeclaration.ParameterList.Parameters[1].Type?.ToString() ?? "";
+            var returnType = opDeclaration.ReturnType.ToString();
+
+            var isMultiplication = opDeclaration.OperatorToken.IsKind(SyntaxKind.AsteriskToken);
+            var isDivision = opDeclaration.OperatorToken.IsKind(SyntaxKind.SlashToken);
+
+            if (!isMultiplication && !isDivision) return null;
+
+            // АВТОМАТИЧЕСКИЙ ПОИСК: Ищем содержащий тип (структуру/рекорд) по синтаксическому дереву
+            string containingTypeName = leftType; // Фолбэк по умолчанию
+            var parentTypeDeclaration = opDeclaration.Ancestors()
+                .OfType<TypeDeclarationSyntax>()
+                .FirstOrDefault();
+
+            if (parentTypeDeclaration != null)
             {
-            if (member is OperatorDeclarationSyntax opDecl &&
+                containingTypeName = parentTypeDeclaration.Identifier.ToString();
-                opDecl.AttributeLists.SelectMany(al => al.Attributes)
-                    .Any(a => a.Name.ToString().Contains(AttributeShortName)))
-                return true;
-        }
-        return false;
             }
 
-    private static TypeInfoData? GetTypeInfo(GeneratorSyntaxContext ctx)
+            string coeffName = null;
+            string coeffType = containingTypeName; // По умолчанию считаем, что коэффициент в текущем классе
+
+            // Извлекаем аргумент атрибута
+            var attribute = opDeclaration.AttributeLists
+                .SelectMany(al => al.Attributes)
+                .FirstOrDefault(a => a.Name.ToString().EndsWith("OperatorsGenerator") || a.Name.ToString() == "OperatorsGenerator");
+
+            if (attribute?.ArgumentList != null && attribute.ArgumentList.Arguments.Count > 0)
             {
-        var typeDecl = (TypeDeclarationSyntax)ctx.Node;
+                var expr = attribute.ArgumentList.Arguments[0].Expression;
-        var semanticModel = ctx.SemanticModel;
 
-        var symbol = semanticModel.GetDeclaredSymbol(typeDecl);
+                // Проверяем синтаксис nameof(...)
-        if (symbol == null) return null;
+                if (expr is InvocationExpressionSyntax invocation &&
-
+                    invocation.Expression.ToString() == "nameof" &&
-        string namespaceName = symbol.ContainingNamespace?.ToString() ?? "";
+                    invocation.ArgumentList.Arguments.Count > 0)
-
-        // Формируем заголовок (для отладочных целей)
-        var headerBuilder = new StringBuilder();
-        foreach (var modifier in typeDecl.Modifiers)
-            headerBuilder.Append(modifier.Text).Append(' ');
-        if (typeDecl is RecordDeclarationSyntax)
-            headerBuilder.Append("record ");
-        headerBuilder.Append(typeDecl.Identifier.Text);
-        string header = headerBuilder.ToString();
-
-        // Собираем операторы
-        var operators = ImmutableArray.CreateBuilder<Operation>();
-        foreach (var member in typeDecl.Members)
                 {
-            if (member is not OperatorDeclarationSyntax opDecl) continue;
+                    var nameofArg = invocation.ArgumentList.Arguments[0].Expression;
-            if (opDecl.ParameterList.Parameters.Count != 2) continue;
-            if (!opDecl.AttributeLists.SelectMany(al => al.Attributes)
-                    .Any(a => a.Name.ToString().Contains(AttributeShortName))) continue;
 
-            operators.Add(new Operation(
+                    // Если все-таки написали явно nameof(Type.Property)
-                opDecl.OperatorToken.Text,
+                    if (nameofArg is MemberAccessExpressionSyntax memberAccess)
-                opDecl.ParameterList.Parameters[0].Type!.ToString(),
-                opDecl.ParameterList.Parameters[1].Type!.ToString(),
-                opDecl.ReturnType.ToString()
-            ));
-        }
-
-        if (operators.Count == 0) return null;
-
-        return new TypeInfoData(namespaceName, typeDecl.Identifier.Text, header, operators.ToImmutable());
-    }
-
-    private static void GenerateOperators(SourceProductionContext context, ImmutableArray<TypeInfoData> types)
                     {
-        foreach (var group in types.GroupBy(t => t.Namespace))
+                        coeffType = memberAccess.Expression.ToString();
+                        coeffName = memberAccess.Name.ToString();
+                    }
+                    else
                     {
-            var document = new StringBuilder();
+                        coeffName = nameofArg.ToString();
-            document.AppendLine("namespace ").Append(group.Key).AppendLine(";");
+                        // coeffType остается равным содержащему классу containingTypeName
-            document.AppendLine("using System.Collections.Generic;");
+                    }
-            document.AppendLine("using System.Linq;");
+                }
-
+                else
-            var allOperators = group.SelectMany(t => t.Operators).ToList();
-            var multiplications = allOperators.Where(op => op.OperatorToken == "*").ToList();
-            var divisions = allOperators.Where(op => op.OperatorToken == "/").ToList();
-
-            // Генерация для умножения: left * collection и collection * left
-            foreach (var mul in multiplications)
                 {
-                // left * collection
+                    coeffName = expr.ToString().Trim('"');
-                document.AppendLine($@"
+                    // coeffType остается равным содержащему классу containingTypeName
-    public static {mul.ReturnType}[] operator *({mul.TypeA} left, {mul.TypeB}[] right) =>
+                }
-        right.Select(u => left * u).ToArray();
-    public static List<{mul.ReturnType}> operator *({mul.TypeA} left, List<{mul.TypeB}> right) =>
-        right.Select(u => left * u).ToList();
-    public static IEnumerable<{mul.ReturnType}> operator *({mul.TypeA} left, IEnumerable<{mul.TypeB}> right) =>
-        right.Select(u => left * u);
-");
-                // collection * left
-                document.AppendLine($@"
-    public static {mul.ReturnType}[] operator *({mul.TypeB}[] left, {mul.TypeA} right) =>
-        left.Select(u => u * right).ToArray();
-    public static List<{mul.ReturnType}> operator *(List<{mul.TypeB}> left, {mul.TypeA} right) =>
-        left.Select(u => u * right).ToList();
-    public static IEnumerable<{mul.ReturnType}> operator *(IEnumerable<{mul.TypeB}> left, {mul.TypeA} right) =>
-        left.Select(u => u * right);
-");
             }
 
-            // Деление: left / collection (left - тип A, collection - тип B)
+            return new OperatorInfo
-            foreach (var div in divisions.Where(op => op.TypeA != null)) // все деления
             {
-                // left / collection
+                Namespace = namespaceName,
-                document.AppendLine($@"
+                LeftType = leftType,
-    public static {div.ReturnType}[] operator /({div.TypeA} left, {div.TypeB}[] right) =>
+                RightType = rightType,
-        right.Select(u => left / u).ToArray();
+                ReturnType = returnType,
-    public static List<{div.ReturnType}> operator /({div.TypeA} left, List<{div.TypeB}> right) =>
+                IsMultiplication = isMultiplication,
-        right.Select(u => left / u).ToList();
+                IsDivision = isDivision,
-    public static IEnumerable<{div.ReturnType}> operator /({div.TypeA} left, IEnumerable<{div.TypeB}> right) =>
+                CoeffName = coeffName,
-        right.Select(u => left / u);
+                CoeffType = coeffType,
-");
+                HasCoeff = !string.IsNullOrWhiteSpace(coeffName)
-                // collection / right (где right - тип B)
+            };
-                document.AppendLine($@"
-    public static {div.ReturnType}[] operator /({div.TypeA}[] left, {div.TypeB} right) =>
-        left.Select(u => u / right).ToArray();
-    public static List<{div.ReturnType}> operator /(List<{div.TypeA}> left, {div.TypeB} right) =>
-        left.Select(u => u / right).ToList();
-    public static IEnumerable<{div.ReturnType}> operator /(IEnumerable<{div.TypeA}> left, {div.TypeB} right) =>
-        left.Select(u => u / right);
-");
         }
 
-            context.AddSource($"operations.{group.Key}.g", document.ToString());
+        private static void Execute(SourceProductionContext context, OperatorInfo info)
-        }
-    }
-
-    private readonly struct TypeInfoData(string ns, string name, string header, ImmutableArray<Operation> ops)
         {
-        public string Namespace { get; } = ns;
+            var opType = info.IsMultiplication ? "Mul" : "Div";
-        public string TypeName { get; } = name;
+            var coeffSuffix = info.HasCoeff ? ".Coeff" : "";
-        public string Header { get; } = header;
+            var hintName = $"Op.{info.LeftType}.{opType}.{info.RightType}{coeffSuffix}.g.cs";
-        public ImmutableArray<Operation> Operators { get; } = ops;
+
+            var source = info.IsMultiplication
+                ? GenerateMultiplicationSource(info)
+                : GenerateDivisionSource(info);
+
+            context.AddSource(hintName, SourceText.From(source, Encoding.UTF8));
         }
 
-    private readonly struct Operation(string token, string a, string b, string ret)
+        private static string GenerateMultiplicationSource(OperatorInfo info)
         {
-        public string OperatorToken { get; } = token;
+            return $@"// <auto-generated />
-        public string TypeA { get; } = a;
+using System;
-        public string TypeB { get; } = b;
+using System.Collections.Generic;
-        public string ReturnType { get; } = ret;
+
+namespace {info.Namespace};
+
+public readonly partial record struct {info.LeftType}
+{{
+    public static {info.ReturnType}[] operator *({info.LeftType} left, {info.RightType}[] right) => {(info.HasCoeff ? $"({info.CoeffType}.{info.CoeffName} * left._Value)" : "left._Value")}.Multiply<{info.RightType}, {info.ReturnType}>(right);
+    public static List<{info.ReturnType}> operator *({info.LeftType} left, List<{info.RightType}> right) => {(info.HasCoeff ? $"({info.CoeffType}.{info.CoeffName} * left._Value)" : "left._Value")}.Multiply<{info.RightType}, {info.ReturnType}>(right);
+    public static IEnumerable<{info.ReturnType}> operator *({info.LeftType} left, IEnumerable<{info.RightType}> right) => {(info.HasCoeff ? $"({info.CoeffType}.{info.CoeffName} * left._Value)" : "left._Value")}.Multiply<{info.RightType}, {info.ReturnType}>(right);
+}}
+
+public readonly partial record struct {info.RightType}
+{{
+    public static {info.ReturnType}[] operator *({info.LeftType}[] left, {info.RightType} right) => {(info.HasCoeff ? $"({info.CoeffType}.{info.CoeffName} * right._Value)" : "right._Value")}.Multiply<{info.LeftType}, {info.ReturnType}>(left);
+    public static List<{info.ReturnType}> operator *(List<{info.LeftType}> left, {info.RightType} right) => {(info.HasCoeff ? $"({info.CoeffType}.{info.CoeffName} * right._Value)" : "right._Value")}.Multiply<{info.LeftType}, {info.ReturnType}>(left);
+    public static IEnumerable<{info.ReturnType}> operator *(IEnumerable<{info.LeftType}> left, {info.RightType} right) => {(info.HasCoeff ? $"({info.CoeffType}.{info.CoeffName} * right._Value)" : "right._Value")}.Multiply<{info.LeftType}, {info.ReturnType}>(left);
+}}";
+        }
+
+        private static string GenerateDivisionSource(OperatorInfo info)
+        {
+            return $@"// <auto-generated />
+using System;
+using System.Collections.Generic;
+
+namespace {info.Namespace};
+
+public readonly partial record struct {info.LeftType}
+{{
+    public static {info.ReturnType}[] operator /({info.LeftType} left, {info.RightType}[] right) => {(info.HasCoeff ? $"({info.CoeffType}.{info.CoeffName} * left._Value)" : "left._Value")}.Divide<{info.RightType}, {info.ReturnType}>(right);
+    public static List<{info.ReturnType}> operator /({info.LeftType} left, List<{info.RightType}> right) => {(info.HasCoeff ? $"({info.CoeffType}.{info.CoeffName} * left._Value)" : "left._Value")}.Divide<{info.RightType}, {info.ReturnType}>(right);
+    public static IEnumerable<{info.ReturnType}> operator /({info.LeftType} left, IEnumerable<{info.RightType}> right) => {(info.HasCoeff ? $"({info.CoeffType}.{info.CoeffName} * left._Value)" : "left._Value")}.Divide<{info.RightType}, {info.ReturnType}>(right);
+}}
+
+public readonly partial record struct {info.RightType}
+{{
+    public static {info.ReturnType}[] operator /({info.LeftType}[] left, {info.RightType} right) => {(info.HasCoeff ? $"left.Multiply<{info.LeftType}, {info.ReturnType}>({info.CoeffType}.{info.CoeffName} / right._Value)" : $"left.Divide<{info.LeftType}, {info.ReturnType}>(right._Value)")};
+    public static List<{info.ReturnType}> operator /(List<{info.LeftType}> left, {info.RightType} right) => {(info.HasCoeff ? $"left.Multiply<{info.LeftType}, {info.ReturnType}>({info.CoeffType}.{info.CoeffName} / right._Value)" : $"left.Divide<{info.LeftType}, {info.ReturnType}>(right._Value)")};
+    public static IEnumerable<{info.ReturnType}> operator /(IEnumerable<{info.LeftType}> left, {info.RightType} right) => {(info.HasCoeff ? $"left.Multiply<{info.LeftType}, {info.ReturnType}>({info.CoeffType}.{info.CoeffName} / right._Value)" : $"left.Divide<{info.LeftType}, {info.ReturnType}>(right._Value)")};
+}}";
+        }
+        
+        private class OperatorInfo
+        {
+            public string Namespace { get; set; } = string.Empty;
+            public string LeftType { get; set; } = string.Empty;
+            public string RightType { get; set; } = string.Empty;
+            public string ReturnType { get; set; } = string.Empty;
+            public bool IsMultiplication { get; set; }
+            public bool IsDivision { get; set; }
+            public string CoeffName { get; set; }
+            public string CoeffType { get; set; }
+            public bool HasCoeff { get; set; } }
     }
 }

QWERTYkez.Mensura/Operators.cs

@@ -1,32 +1,5 @@
 namespace QWERTYkez.Mensura.Units;
 
-internal static class OperationsExtension
-{
-    internal static TResult MultiplyProtected<T1, T2, TResult>(this T1 t1, T2 t2)
-        where T1 : struct, IMensuraUnit<T1>, IEquatable<T1>, IMensuraUnit
-        where T2 : struct, IMensuraUnit<T2>, IEquatable<T2>, IMensuraUnit
-        where TResult : struct, IMensuraUnit<TResult>, IEquatable<TResult>, IMensuraUnit
-        => (t1.ToDouble() * t2.ToDouble()).ToUnit<TResult>();
-
-    internal static TResult MultiplyProtected<T1, T2, TResult>(this T1 t1, T2 t2, double multiplicator)
-        where T1 : struct, IMensuraUnit<T1>, IEquatable<T1>, IMensuraUnit
-        where T2 : struct, IMensuraUnit<T2>, IEquatable<T2>, IMensuraUnit
-        where TResult : struct, IMensuraUnit<TResult>, IEquatable<TResult>, IMensuraUnit
-        => (t1.ToDouble() * t2.ToDouble() * multiplicator).ToUnit<TResult>();
-
-    internal static TResult DivideProtected<T1, T2, TResult>(this T1 t1, T2 t2)
-        where T1 : struct, IMensuraUnit<T1>, IEquatable<T1>, IMensuraUnit
-        where T2 : struct, IMensuraUnit<T2>, IEquatable<T2>, IMensuraUnit
-        where TResult : struct, IMensuraUnit<TResult>, IEquatable<TResult>, IMensuraUnit
-        => (t1.ToDouble() / t2.ToDouble()).ToUnit<TResult>();
-
-    internal static TResult DivideProtected<T1, T2, TResult>(this T1 t1, T2 t2, double multiplicator)
-        where T1 : struct, IMensuraUnit<T1>, IEquatable<T1>, IMensuraUnit
-        where T2 : struct, IMensuraUnit<T2>, IEquatable<T2>, IMensuraUnit
-        where TResult : struct, IMensuraUnit<TResult>, IEquatable<TResult>, IMensuraUnit
-        => (t1.ToDouble() * multiplicator / t2.ToDouble()).ToUnit<TResult>();
-}
-
 internal static class Coefficients
 {
     internal static double MultiplyCoefficient<T1, T2, TResult>(T1 a, T2 b, TResult r)
@@ -45,172 +18,153 @@ internal static class Coefficients
 
 
 
-[CollectionsOperatorsGenerator] public readonly partial record struct Length
+
+
+public readonly partial record struct Length
 {
-    [CollectionsOperatorsGenerator] public static Area operator *(Length left, Length right)
+    [OperatorsGenerator] public static Area operator *(Length left, Length right) => new(left._Value * right._Value);
-        => left.MultiplyProtected<Length, Length, Area>(right, Coeff1);
-
-    static readonly double Coeff1 = Coefficients.MultiplyCoefficient(MilliMeter, MilliMeter, Area.MilliMeterSquared);
 
 
-    [CollectionsOperatorsGenerator] public static Volume operator *(Area left, Length right) => right * left;
+    public static Volume operator *(Area left, Length right) => right * left;
-    [CollectionsOperatorsGenerator] public static Volume operator *(Length left, Area right)
+    [OperatorsGenerator] public static Volume operator *(Length left, Area right) => new(left._Value * right._Value);
-        => left.MultiplyProtected<Length, Area, Volume>(right, Coeff2);
-
-    static readonly double Coeff2 = Coefficients.MultiplyCoefficient(MilliMeter, Area.MilliMeterSquared, Volume.MilliMeterCubic);
 
 
-    [CollectionsOperatorsGenerator] public static Pressure operator *(Length left, ForceVolumetric right) => right * left;
+    public static Pressure operator *(Length left, ForceVolumetric right) => right * left;
-    [CollectionsOperatorsGenerator] public static Pressure operator *(ForceVolumetric left, Length right) => left.MultiplyProtected<ForceVolumetric, Length, Pressure>(right, Coeff3);
+    [OperatorsGenerator(nameof(Coeff1))] public static Pressure operator *(ForceVolumetric left, Length right) => new(left._Value * right._Value * Coeff1);
-    static readonly double Coeff3 = Coefficients.MultiplyCoefficient(ForceVolumetric.NewtonPerMeterCubic, Length.Meter, Pressure.NewtonPerMeterSquared);
+    public static readonly double Coeff1 = Coefficients.MultiplyCoefficient(ForceVolumetric.NewtonPerMeterCubic, Length.Meter, Pressure.NewtonPerMeterSquared);
 
 
-    [CollectionsOperatorsGenerator] public static Torque operator *(Force left, Length right) => right * left;
+    public static Torque operator *(Force left, Length right) => right * left;
-    [CollectionsOperatorsGenerator] public static Torque operator *(Length left, Force right) => left.MultiplyProtected<Length, Force, Torque>(right, Coeff6);
+    [OperatorsGenerator(nameof(Coeff2))] public static Torque operator *(Length left, Force right) => new(left._Value * right._Value * Coeff2);
-    static readonly double Coeff6 = Coefficients.MultiplyCoefficient(Length.Meter, Force.Newton, Torque.Newton_Meter);
+    public static readonly double Coeff2 = Coefficients.MultiplyCoefficient(Length.Meter, Force._Newton, Torque._Newton_Meter);
 }
 
-[CollectionsOperatorsGenerator] public readonly partial record struct Mass // Grams
+public readonly partial record struct Mass // Grams
 {
 
 }
 
-[CollectionsOperatorsGenerator] public readonly partial record struct Pressure // Pascals
+public readonly partial record struct Pressure // Pascals
 {
-    [CollectionsOperatorsGenerator] public static Length operator /(Pressure left, ForceVolumetric right) => left.DivideProtected<Pressure, ForceVolumetric, Length>(right, Coeff1);
+    [OperatorsGenerator(nameof(Coeff1))] public static Length operator /(Pressure left, ForceVolumetric right) => new(left._Value * Coeff1 / right._Value);
-    static readonly double Coeff1 = Coefficients.DivideCoefficient(Pressure.Pascal, ForceVolumetric.NewtonPerMeterCubic, Length.Meter);
+    public static readonly double Coeff1 = Coefficients.DivideCoefficient(Pressure._Pascal, ForceVolumetric.NewtonPerMeterCubic, Length.Meter);
 
-    [CollectionsOperatorsGenerator] public static Force operator *(Pressure left, Area right) => right * left;
+    public static Force operator *(Pressure left, Area right) => right * left;
-    [CollectionsOperatorsGenerator] public static Force operator *(Area left, Pressure right) => left.MultiplyProtected<Area, Pressure, Force>(right, Coeff2);
+    [OperatorsGenerator(nameof(Coeff2))] public static Force operator *(Area left, Pressure right) => new (left._Value * right._Value * Coeff2);
-    static readonly double Coeff2 = Coefficients.MultiplyCoefficient(Area.MeterSquared, Pressure.Pascal, Force.Newton);
+    public static readonly double Coeff2 = Coefficients.MultiplyCoefficient(Area.MeterSquared, Pressure._Pascal, Force._Newton);
 
 
 
-    [CollectionsOperatorsGenerator] public static Length operator /(ForceLinear left, Pressure right) => left.DivideProtected<ForceLinear, Pressure, Length>(right, Coeff3);
+    [OperatorsGenerator(nameof(Coeff3))] public static Length operator /(ForceLinear left, Pressure right) => new(left._Value * Coeff3 / right._Value);
-    static readonly double Coeff3 = Coefficients.DivideCoefficient(ForceLinear._NewtonPerMilliMeter, Pressure.NewtonPerMilliMeterSquared, Length.MilliMeter);
+    public static readonly double Coeff3 = Coefficients.DivideCoefficient(ForceLinear._NewtonPerMilliMeter, Pressure.NewtonPerMilliMeterSquared, Length._MilliMeter);
 
-    [CollectionsOperatorsGenerator] public static ForceLinear operator *(Pressure left, Length right) => right * left;
+    public static ForceLinear operator *(Pressure left, Length right) => right * left;
-    [CollectionsOperatorsGenerator] public static ForceLinear operator *(Length left, Pressure right) => left.MultiplyProtected<Length, Pressure, ForceLinear>(right, Coeff4);
+    [OperatorsGenerator(nameof(Coeff4))] public static ForceLinear operator *(Length left, Pressure right) => new(left._Value * right._Value * Coeff4);
-    static readonly double Coeff4 = Coefficients.MultiplyCoefficient(Length.MilliMeter, Pressure.NewtonPerMilliMeterSquared, ForceLinear._NewtonPerMilliMeter);
+    public static readonly double Coeff4 = Coefficients.MultiplyCoefficient(Length._MilliMeter, Pressure.NewtonPerMilliMeterSquared, ForceLinear._NewtonPerMilliMeter);
 }
 
-[CollectionsOperatorsGenerator] public readonly partial record struct Area // MilliMetersSquared
+public readonly partial record struct Area // MilliMetersSquared
 {
-    [CollectionsOperatorsGenerator] public static Torque operator *(ForceLinear left, Area right) => right * left;
+    public static Torque operator *(ForceLinear left, Area right) => right * left;
-    [CollectionsOperatorsGenerator] public static Torque operator *(Area left, ForceLinear right) => left.MultiplyProtected<Area, ForceLinear, Torque>(right, Coeff1);
+    [OperatorsGenerator(nameof(Coeff1))] public static Torque operator *(Area left, ForceLinear right) => new(left._Value * right._Value * Coeff1);
-    static readonly double Coeff1 = Coefficients.MultiplyCoefficient(Area.MeterSquared, ForceLinear.NewtonPerMeter, Torque.Newton_Meter);
+    public static readonly double Coeff1 = Coefficients.MultiplyCoefficient(Area.MeterSquared, ForceLinear.NewtonPerMeter, Torque._Newton_Meter);
 
-    [CollectionsOperatorsGenerator] public static Length operator /(Area left, Length right) => left.DivideProtected<Area, Length, Length>(right, Coeff2);
+    [OperatorsGenerator] public static Length operator /(Area left, Length right) => new(left._Value / right._Value);
-    static readonly double Coeff2 = Coefficients.DivideCoefficient(Area.MilliMeterSquared, Length.MilliMeter, Length.MilliMeter);
 }
 
-[CollectionsOperatorsGenerator] public readonly partial record struct Volume // MillimetersCubic
+public readonly partial record struct Volume // MillimetersCubic
 {
-    [CollectionsOperatorsGenerator] public static Torque operator *(Pressure left, Volume right) => right * left;
+    public static Torque operator *(Pressure left, Volume right) => right * left;
-    [CollectionsOperatorsGenerator] public static Torque operator *(Volume left, Pressure right) => left.MultiplyProtected<Volume, Pressure, Torque>(right, Coeff2);
+    [OperatorsGenerator(nameof(Coeff2))] public static Torque operator *(Volume left, Pressure right) => new(left._Value * right._Value * Coeff2);
-    static readonly double Coeff2 = Coefficients.MultiplyCoefficient(Volume.MeterCubic, Pressure.Pascal, Torque.Newton_Meter);
+    public static readonly double Coeff2 = Coefficients.MultiplyCoefficient(Volume.MeterCubic, Pressure._Pascal, Torque._Newton_Meter);
 
-    [CollectionsOperatorsGenerator] public static Area operator /(Volume left, Length right) => left.DivideProtected<Volume, Length, Area>(right);
+    [OperatorsGenerator] public static Area operator /(Volume left, Length right) => new(left._Value / right._Value);
-    [CollectionsOperatorsGenerator] public static Length operator /(Volume left, Area right) => left.DivideProtected<Volume, Area, Length>(right, Coeff3);
+    [OperatorsGenerator] public static Length operator /(Volume left, Area right) => new(left._Value / right._Value);
-    static readonly double Coeff3 = Coefficients.DivideCoefficient(Volume.MilliMeterCubic, Length.MilliMeter, Area.MilliMeterSquared);
 }
 
-[CollectionsOperatorsGenerator] public readonly partial record struct Force // Newtons
+public readonly partial record struct Force // Newtons
 {
-    [CollectionsOperatorsGenerator] public static Area operator /(Force left, Pressure right) => left.DivideProtected<Force, Pressure, Area>(right, Coeff1);
+    [OperatorsGenerator(nameof(Coeff1))] public static Area operator /(Force left, Pressure right) => new(left._Value * Coeff1 / right._Value);
-    static readonly double Coeff1 = Coefficients.DivideCoefficient(Force.Newton, Pressure.Pascal, Area.MeterSquared);
+    public static readonly double Coeff1 = Coefficients.DivideCoefficient(Force._Newton, Pressure._Pascal, Area.MeterSquared);
-    [CollectionsOperatorsGenerator] public static Pressure operator /(Force left, Area right) => left.DivideProtected<Force, Area, Pressure>(right, Coeff2);
+    [OperatorsGenerator(nameof(Coeff2))] public static Pressure operator /(Force left, Area right) => new(left._Value * Coeff2 / right._Value);
-    static readonly double Coeff2 = Coefficients.DivideCoefficient(Force.Newton, Area.MeterSquared, Pressure.Pascal);
+    public static readonly double Coeff2 = Coefficients.DivideCoefficient(Force._Newton, Area.MeterSquared, Pressure._Pascal);
 
 }
 
-[CollectionsOperatorsGenerator] public readonly partial record struct Torque // NewtonMeters
+public readonly partial record struct Torque // NewtonMeters
 {
-    [CollectionsOperatorsGenerator] public static Length operator /(Torque left, Force right) => left.DivideProtected<Torque, Force, Length>(right, Coeff1);
+    [OperatorsGenerator(nameof(Coeff1))] public static Length operator /(Torque left, Force right) => new(left._Value * Coeff1 / right._Value);
-    static readonly double Coeff1 = Coefficients.DivideCoefficient(Torque.Newton_Meter, Force.Newton, Length.Meter);
+    public static readonly double Coeff1 = Coefficients.DivideCoefficient(Torque._Newton_Meter, Force._Newton, Length.Meter);
-    [CollectionsOperatorsGenerator] public static Force operator /(Torque left, Length right) => left.DivideProtected<Torque, Length, Force>(right, Coeff2);
+    [OperatorsGenerator(nameof(Coeff2))] public static Force operator /(Torque left, Length right) => new(left._Value * Coeff2 / right._Value);
-    static readonly double Coeff2 = Coefficients.DivideCoefficient(Torque.Newton_Meter, Length.Meter, Force.Newton);
+    public static readonly double Coeff2 = Coefficients.DivideCoefficient(Torque._Newton_Meter, Length.Meter, Force._Newton);
-    [CollectionsOperatorsGenerator] public static ForceLinear operator /(Torque left, Area right) => left.DivideProtected<Torque, Area, ForceLinear>(right, Coeff3);
+    [OperatorsGenerator(nameof(Coeff3))] public static ForceLinear operator /(Torque left, Area right) => new(left._Value * Coeff3 / right._Value);
-    static readonly double Coeff3 = Coefficients.DivideCoefficient(Torque.Newton_Meter, Area.MilliMeterSquared, ForceLinear.KiloNewtonPerMilliMeter );
+    public static readonly double Coeff3 = Coefficients.DivideCoefficient(Torque._Newton_Meter, Area._MilliMeterSquared, ForceLinear.KiloNewtonPerMilliMeter );
-    [CollectionsOperatorsGenerator] public static Pressure operator /(Torque left, Volume right) => left.DivideProtected<Torque, Volume, Pressure>(right, Coeff4);
+    [OperatorsGenerator(nameof(Coeff4))] public static Pressure operator /(Torque left, Volume right) => new(left._Value * Coeff4 / right._Value);
-    static readonly double Coeff4 = Coefficients.DivideCoefficient(Torque.Newton_Meter, Volume.MeterCubic, Pressure.Pascal);
+    public static readonly double Coeff4 = Coefficients.DivideCoefficient(Torque._Newton_Meter, Volume.MeterCubic, Pressure._Pascal);
-    [CollectionsOperatorsGenerator] public static Volume operator /(Torque left, Pressure right) => left.DivideProtected<Torque, Pressure, Volume>(right, Coeff5);
+    [OperatorsGenerator(nameof(Coeff5))] public static Volume operator /(Torque left, Pressure right) => new(left._Value * Coeff5 / right._Value);
-    static readonly double Coeff5 = Coefficients.DivideCoefficient(Torque.Newton_Meter, Pressure.Pascal, Volume.MeterCubic);
+    public static readonly double Coeff5 = Coefficients.DivideCoefficient(Torque._Newton_Meter, Pressure._Pascal, Volume.MeterCubic);
 }
 
-[CollectionsOperatorsGenerator] public readonly partial record struct Frequency // Hertz
+public readonly partial record struct Frequency // Hertz
 {
 
 }
 
-[CollectionsOperatorsGenerator] public readonly partial record struct Time
+public readonly partial record struct Time
 {
-    [CollectionsOperatorsGenerator] public static Speed operator *(Boost left, Time right) => right * left;
+    public static Speed operator *(Boost left, Time right) => right * left;
-    [CollectionsOperatorsGenerator] public static Speed operator *(Time left, Boost right) => left.MultiplyProtected<Time, Boost, Speed>(right, Coeff1);
+    [OperatorsGenerator(nameof(Coeff1))] public static Speed operator *(Time left, Boost right) => new(left._Value * right._Value * Coeff1);
-    static readonly double Coeff1 = Coefficients.MultiplyCoefficient(Time.Second, Boost.MeterPerSecondSquared, Speed.MeterPerSecond);
+    public static readonly double Coeff1 = Coefficients.MultiplyCoefficient(Time.Second, Boost._MeterPerSecondSquared, Speed.MeterPerSecond);
 
-    [CollectionsOperatorsGenerator] public static Speed operator /(Length left, Time right) => left.DivideProtected<Length, Time, Speed>(right, Coeff2);
+    [OperatorsGenerator(nameof(Coeff2))] public static Speed operator /(Length left, Time right) => new(left._Value * Coeff2 / right._Value);
-    static readonly double Coeff2 = Coefficients.DivideCoefficient(Length.Meter, Time.Second, Speed.MeterPerSecond);
+    public static readonly double Coeff2 = Coefficients.DivideCoefficient(Length.Meter, Time.Second, Speed.MeterPerSecond);
 }
 
-[CollectionsOperatorsGenerator] public readonly partial record struct Speed
+public readonly partial record struct Speed
 {
-    [CollectionsOperatorsGenerator] public static Length operator *(Speed left, Time right) => right * left;
+    public static Length operator *(Speed left, Time right) => right * left;
-    [CollectionsOperatorsGenerator] public static Length operator *(Time left, Speed right) => left.MultiplyProtected<Time, Speed, Length>(right, Coeff1);
+    [OperatorsGenerator(nameof(Coeff1))] public static Length operator *(Time left, Speed right) => new(left._Value * right._Value * Coeff1);
-    static readonly double Coeff1 = Coefficients.MultiplyCoefficient(Time.Second, Speed.MeterPerSecond, Length.Meter);
+    public static readonly double Coeff1 = Coefficients.MultiplyCoefficient(Time.Second, Speed.MeterPerSecond, Length.Meter);
 
-    [CollectionsOperatorsGenerator] public static Boost operator /(Speed left, Time right) => left.DivideProtected<Speed, Time, Boost>(right, Coeff2);
+    [OperatorsGenerator(nameof(Coeff2))] public static Boost operator /(Speed left, Time right) => new(left._Value * Coeff2 / right._Value);
-    static readonly double Coeff2 = Coefficients.DivideCoefficient(Speed.MeterPerSecond, Time.Second, Boost.MeterPerSecondSquared);
+    public static readonly double Coeff2 = Coefficients.DivideCoefficient(Speed.MeterPerSecond, Time.Second, Boost._MeterPerSecondSquared);
 }
 
-[CollectionsOperatorsGenerator] public readonly partial record struct Boost
+public readonly partial record struct Boost
 {
-    [CollectionsOperatorsGenerator] public static Force operator *(Mass left, Boost right) => right * left;
+    public static Force operator *(Mass left, Boost right) => right * left;
-    [CollectionsOperatorsGenerator] public static Force operator *(Boost left, Mass right) => left.MultiplyProtected<Boost, Mass, Force>(right, Coeff1);
+    [OperatorsGenerator(nameof(Coeff1))] public static Force operator *(Boost left, Mass right) => new(left._Value * right._Value * Coeff1);
-    static readonly double Coeff1 = Coefficients.MultiplyCoefficient(Boost.MeterPerSecondSquared, Mass.KiloGram, Force.Newton);
+    public static readonly double Coeff1 = Coefficients.MultiplyCoefficient(Boost._MeterPerSecondSquared, Mass.KiloGram, Force._Newton);
 
-    [CollectionsOperatorsGenerator] public static ForceLinear operator *(MassLinear left, Boost right) => right * left;
+    public static ForceLinear operator *(MassLinear left, Boost right) => right * left;
-    [CollectionsOperatorsGenerator] public static ForceLinear operator *(Boost left, MassLinear right) => left.MultiplyProtected<Boost, MassLinear, ForceLinear>(right, Coeff2);
+    [OperatorsGenerator(nameof(Coeff2))] public static ForceLinear operator *(Boost left, MassLinear right) => new(left._Value * right._Value * Coeff2);
-    static readonly double Coeff2 = Coefficients.MultiplyCoefficient(Boost.MeterPerSecondSquared, MassLinear.KiloGramPerMilliMeter, ForceLinear._NewtonPerMilliMeter);
+    public static readonly double Coeff2 = Coefficients.MultiplyCoefficient(Boost._MeterPerSecondSquared, MassLinear.KiloGramPerMilliMeter, ForceLinear._NewtonPerMilliMeter);
 
-    [CollectionsOperatorsGenerator] public static ForceVolumetric operator *(Density left, Boost right) => right * left;
+    public static ForceVolumetric operator *(Density left, Boost right) => right * left;
-    [CollectionsOperatorsGenerator] public static ForceVolumetric operator *(Boost left, Density right) => left.MultiplyProtected<Boost, Density, ForceVolumetric>(right, Coeff3);
+    [OperatorsGenerator(nameof(Coeff3))] public static ForceVolumetric operator *(Boost left, Density right) => new(left._Value * right._Value * Coeff3);
-    static readonly double Coeff3 = Coefficients.MultiplyCoefficient(Boost.MeterPerSecondSquared, Density.KiloGramPerMilliMeterCubic, ForceVolumetric._NewtonPerMilliMeterCubic);
+    public static readonly double Coeff3 = Coefficients.MultiplyCoefficient(Boost._MeterPerSecondSquared, Density.KiloGramPerMilliMeterCubic, ForceVolumetric._NewtonPerMilliMeterCubic);
 
 
-    [CollectionsOperatorsGenerator] public static MassLinear operator /(ForceLinear left, Boost right) => left.DivideProtected<ForceLinear, Boost, MassLinear>(right, Coeff4);
+    [OperatorsGenerator(nameof(Coeff4))] public static MassLinear operator /(ForceLinear left, Boost right) => new(left._Value * Coeff4 / right._Value);
-    static readonly double Coeff4 = Coefficients.DivideCoefficient(ForceLinear._NewtonPerMilliMeter, Boost.MeterPerSecondSquared, MassLinear.KiloGramPerMilliMeter);
+    public static readonly double Coeff4 = Coefficients.DivideCoefficient(ForceLinear._NewtonPerMilliMeter, Boost._MeterPerSecondSquared, MassLinear.KiloGramPerMilliMeter);
 
-    [CollectionsOperatorsGenerator] public static Density operator /(ForceVolumetric left, Boost right) => left.DivideProtected<ForceVolumetric, Boost, Density>(right, Coeff5);
+    [OperatorsGenerator(nameof(Coeff5))] public static Density operator /(ForceVolumetric left, Boost right) => new(left._Value * Coeff5 / right._Value);
-    static readonly double Coeff5 = Coefficients.DivideCoefficient(ForceVolumetric._NewtonPerMilliMeterCubic, Boost.MeterPerSecondSquared, Density.KiloGramPerMilliMeterCubic);
+    public static readonly double Coeff5 = Coefficients.DivideCoefficient(ForceVolumetric._NewtonPerMilliMeterCubic, Boost._MeterPerSecondSquared, Density.KiloGramPerMilliMeterCubic);
 
 
-    [CollectionsOperatorsGenerator] public static MassPerSquare operator /(Pressure left, Boost right) => left.DivideProtected<Pressure, Boost, MassPerSquare>(right, Coeff6);
+    [OperatorsGenerator] public static MassPerSquare operator /(Pressure left, Boost right) => new(left._Value / right._Value);
-    static readonly double Coeff6 = Coefficients.DivideCoefficient(Pressure.Pascal, Boost.MeterPerSecondSquared, MassPerSquare.KiloGramPerMeterSquared);
 }
 
-[CollectionsOperatorsGenerator] public readonly partial record struct MassPerSquare
+public readonly partial record struct MassPerSquare
 {
-    [CollectionsOperatorsGenerator] public static Pressure operator *(Boost left, MassPerSquare right) => right * left;
+    public static Pressure operator *(Boost left, MassPerSquare right) => right * left;
-    [CollectionsOperatorsGenerator] public static Pressure operator *(MassPerSquare left, Boost right) => left.MultiplyProtected<MassPerSquare, Boost, Pressure>(right, Coeff1);
+    [OperatorsGenerator] public static Pressure operator *(MassPerSquare left, Boost right) => new(left._Value * right._Value);
-    static readonly double Coeff1 = Coefficients.MultiplyCoefficient(MassPerSquare.KiloGramPerMeterSquared, Boost.MeterPerSecondSquared, Pressure.Pascal);
 }
 
-//[CollectionsOperatorsGenerator] public readonly partial record struct LinearForce : Pogon<LinearForce, Force>
-//{
 
+public readonly partial record struct MassLinear
+{
+    [OperatorsGenerator(nameof(Coeff1))] public static Boost operator /(ForceLinear left, MassLinear right) => new(left._Value * Coeff1 / right._Value);
 
-//}
+    public static readonly double Coeff1 = Coefficients.DivideCoefficient(ForceLinear._NewtonPerMilliMeter, MassLinear.KiloGramPerMilliMeter, Boost._MeterPerSecondSquared);
-
+}
-//[CollectionsOperatorsGenerator] public readonly partial record struct MassLinear : Pogon<MassLinear, Mass>
-//{
-//    [CollectionsOperatorsGenerator] public static Boost operator /(LinearForce left, MassLinear right) => left.DivideProtected<LinearForce, MassLinear, Boost>(right, Coeff1);
-
-//    static readonly double Coeff1 = Coefficients.DivideCoefficient(a => a.PerMilliMeter.Newtons = 1, b => b.PerMilliMeter.KiloGrams = 1, Boost.MeterPerSecondSquared);
-//}
-
-//[CollectionsOperatorsGenerator] public readonly partial record struct ForceVolumetric : Udel<ForceVolumetric, Force>
-//{
-
-
-//}

QWERTYkez.Mensura/Units/Angle.cs

@@ -6,7 +6,7 @@
 [UnitGenerator, DebuggerDisplay("Radians = {Radians.ToString(\"0.###\")}, Degrees = {Degrees.ToString(\"0.###\")}")]
 public readonly partial record struct Angle
 {
-	public static Angle Second { get; } = new() { _Seconds = 1 };
+	public static Angle _Second { get; } = new() { _Seconds = 1 };
 	[NotMapped, JsonIgnore] public double _Seconds { get => _Value; init => _Value = value; }
 
 

QWERTYkez.Mensura/Units/Area.cs

@@ -6,7 +6,7 @@
 [UnitGenerator, DebuggerDisplay("mm2 = {_MilliMetersSquared.ToString(\"0.###\")}, m2 = {MetersSquared.ToString(\"0.###\")}")]
 public readonly partial record struct Area
 {
-	public static Area MilliMeterSquared { get; } = new() { _MilliMetersSquared = 1 };
+	public static Area _MilliMeterSquared { get; } = new() { _MilliMetersSquared = 1 };
 	[NotMapped, JsonIgnore] public double _MilliMetersSquared { get => _Value; init => _Value = value; }
 
 

QWERTYkez.Mensura/Units/Boost.cs

@@ -6,7 +6,7 @@
 [UnitGenerator, DebuggerDisplay("m/s2 = {_MetersPerSecondSquared.ToString(\"0.###\")}")]
 public readonly partial record struct Boost
 {
-	public static Boost MeterPerSecondSquared { get; } = new() { _MetersPerSecondSquared = 1 };
+	public static Boost _MeterPerSecondSquared { get; } = new() { _MetersPerSecondSquared = 1 };
 	[NotMapped, JsonIgnore] public double _MetersPerSecondSquared { get => _Value; init => _Value = value; }
 
 

QWERTYkez.Mensura/Units/Complex/ForceLinear.cs

@@ -1,4 +1,4 @@
-namespace QWERTYkez.Mensura.Units.Complex;
+namespace QWERTYkez.Mensura.Units;
 
 [ComplexUnitGenerator(nameof(Force), nameof(Length), nameof(ForceLinear))] public readonly partial record struct ForceLinear
 {
@@ -57,22 +57,3 @@
     }
 
 }
-
-
-
-
-
-//namespace MetricSystem;
-
-//[DebuggerDisplay("N/m = {PerMeter._Newtons.ToString(\"0.###\")}, kgf/m = {PerMeter.KiloGramXXXXXXXXs.ToString(\"0.###\")}")]
-//public readonly partial record struct PogonXXXXXXXX
-//{
-
-
-//}
-
-//public partial class Length : Metric<Length, Length>
-//{
-//    [CollectionsOperatorsGenerator] public static PogonXXXXXXXX operator /(XXXXXXXX left, Length right) => left.DivideProtected<XXXXXXXX, Length, PogonXXXXXXXX>(right, PogonXXXXXXXXCoeff);
-//    static readonly double PogonXXXXXXXXCoeff = Coefficients.DivideCoefficient<XXXXXXXX, Length, PogonXXXXXXXX>(a => a.Value = 1, b => b._MilliMeters = 1, r => r._PerMilliMeter.Value = 1);
-//}

QWERTYkez.Mensura/Units/Complex/ForceVolumetric.cs

@@ -1,4 +1,4 @@
-namespace QWERTYkez.Mensura.Units.Complex;
+namespace QWERTYkez.Mensura.Units;
 
 [ComplexUnitGenerator(nameof(Force), nameof(Volume), nameof(ForceVolumetric))] public readonly partial record struct ForceVolumetric
 {
@@ -33,24 +33,3 @@
     }
 
 }
-
-
-
-
-
-//namespace MetricSystem;
-
-//[Owned, JsonConverter(typeof(MetricFormatter<ForceVolumetric>)), DebuggerDisplay("N/(m*mm2) = {PerMeter_PerMilliMeterSquared._Newtons.ToString(\"0.###\")}, kgf/(m*mm2) = {PerMeter_PerMilliMeterSquared.KiloGramForces.ToString(\"0.###\")}")]
-//public partial class ForceVolumetric : Udel<ForceVolumetric, Force>
-//{
-//    [CollectionsOperatorsGenerator] public static ForceVolumetric operator *(Area left, ForceVolumetric right) => right * left;
-
-//    [CollectionsOperatorsGenerator] public static ForceVolumetric operator *(ForceVolumetric left, Area right) => left.MultiplyProtected<ForceVolumetric, Area, ForceVolumetric>(right, ForceVolumetricCoeff);
-//    static readonly double ForceVolumetricCoeff = Coefficients.MultiplyCoefficient<ForceVolumetric, Area, ForceVolumetric>(a => a._PerMilliMeterCubic.Value = 1, b => b._MilliMetersSquared = 1, r => r._PerMilliMeter.Value = 1);
-//}
-
-//public partial class Volume : Metric<Volume, Volume>
-//{
-//    [CollectionsOperatorsGenerator] public static ForceVolumetric operator /(Force left, Volume right) => left.DivideProtected<Force, Volume, ForceVolumetric>(right, ForceVolumetricCoeff);
-//    static readonly double ForceVolumetricCoeff = Coefficients.DivideCoefficient<Force, Volume, ForceVolumetric>(a => a.Value = 1, b => b._MilliMetersCubic = 1, r => r._PerMilliMeterCubic.Value = 1);
-//}

QWERTYkez.Mensura/Units/Complex/MassLinear.cs

@@ -1,4 +1,4 @@
-namespace QWERTYkez.Mensura.Units.Complex;
+namespace QWERTYkez.Mensura.Units;
 
 [ComplexUnitGenerator(nameof(Mass), nameof(Length), nameof(MassLinear))] public readonly partial record struct MassLinear
 {
@@ -57,26 +57,3 @@
     }
 
 }
-
-
-
-
-
-
-
-
-
-
-
-//[Owned, JsonConverter(typeof(MetricFormatter<MassLinear>)), DebuggerDisplay("gr/m = {PerMeter._Grams.ToString(\"0.###\")}, kg/m = {PerMeter.KiloGrams.ToString(\"0.###\")}")]
-//public partial class MassLinear : Pogon<MassLinear, Mass>
-//{
-//    [CollectionsOperatorsGenerator] public static Density operator /(MassLinear left, Area right) => left.DivideProtected<MassLinear, Area, Density>(right, UdelMassCoeff);
-//    static readonly double UdelMassCoeff = Coefficients.DivideCoefficient<MassLinear, Area, Density>(a => a._PerMilliMeter.Value = 1, b => b._MilliMetersSquared = 1, r => r._PerMilliMeterCubic.Value = 1);
-//}
-
-//public partial class Length : Metric<Length, Length>
-//{
-//    [CollectionsOperatorsGenerator] public static MassLinear operator /(Mass left, Length right) => left.DivideProtected<Mass, Length, MassLinear>(right, MassLinearCoeff);
-//    static readonly double MassLinearCoeff = Coefficients.DivideCoefficient<Mass, Length, MassLinear>(a => a.Value = 1, b => b._MilliMeters = 1, r => r._PerMilliMeter.Value = 1);
-//}

QWERTYkez.Mensura/Units/Complex/MassVolumetric (Density).cs

@@ -1,4 +1,4 @@
-namespace QWERTYkez.Mensura.Units.Complex;
+namespace QWERTYkez.Mensura.Units;
 
 [ComplexUnitGenerator(nameof(Mass), nameof(Volume), nameof(Density))] public readonly partial record struct Density
 {
@@ -33,27 +33,3 @@
     }
 
 }
-
-
-
-
-
-
-
-
-//namespace MetricSystem;
-
-//[Owned, JsonConverter(typeof(MetricFormatter<Density>)), DebuggerDisplay("gr/(m*mm2) = {PerMeterCubic_PerMilliMetersCubicquared._Grams.ToString(\"0.###\")}, kg/(m*mm2) = {PerMeterCubic_PerMilliMetersCubicquared.KiloGrams.ToString(\"0.###\")}")]
-//public partial class Density : Udel<Density, Mass>
-//{
-//    [CollectionsOperatorsGenerator] public static PogonMass operator *(Area left, Density right) => right * left;
-
-//    [CollectionsOperatorsGenerator] public static PogonMass operator *(Density left, Area right) => left.MultiplyProtected<Density, Area, PogonMass>(right, PogonMassCoeff);
-//    static readonly double PogonMassCoeff = Coefficients.MultiplyCoefficient<Density, Area, PogonMass>(a => a._PerMilliMeterCubicCubic.Value = 1, b => b._MilliMetersCubicSquared = 1, r => r._PerMilliMeterCubic.Value = 1);
-//}
-
-//public partial class Volume : Metric<Volume, Volume>
-//{
-//    [CollectionsOperatorsGenerator] public static Density operator /(Mass left, Volume right) => left.DivideProtected<Mass, Volume, Density>(right, DensityCoeff);
-//    static readonly double DensityCoeff = Coefficients.DivideCoefficient<Mass, Volume, Density>(a => a.Value = 1, b => b._MilliMetersCubicCubic = 1, r => r._PerMilliMeterCubicCubic.Value = 1);
-//}

QWERTYkez.Mensura/Units/Force.cs

@@ -6,7 +6,7 @@
 [UnitGenerator, DebuggerDisplay("N = {_Newtons.ToString(\"0.###\")}, kgf = {KiloGramForces.ToString(\"0.###\")}")]
 public readonly partial record struct Force
 {
-    public static Force Newton { get; } = new() { _Newtons = 1 };
+    public static Force _Newton { get; } = new() { _Newtons = 1 };
     [NotMapped, JsonIgnore] public double _Newtons { get => _Value; init => _Value = value; }
 
 

QWERTYkez.Mensura/Units/Frequency.cs

@@ -6,7 +6,7 @@
 [UnitGenerator, DebuggerDisplay("Hz = {_Hertz.ToString(\"0.###\")}")]
 public readonly partial record struct Frequency
 {
-	public static Frequency OneHertz { get; } = new() { _Hertz = 1 };
+	public static Frequency _OneHertz { get; } = new() { _Hertz = 1 };
 	[NotMapped, JsonIgnore] public double _Hertz { get => _Value; init => _Value = value; }
 
 

QWERTYkez.Mensura/Units/Length.cs

@@ -6,7 +6,7 @@
 [UnitGenerator, DebuggerDisplay("mm = {_MilliMeters.ToString(\"0.###\")}, m = {Meters.ToString(\"0.###\")}")]
 public readonly partial record struct Length
 {
-    public static Length MilliMeter { get; } = new(1);
+    public static Length _MilliMeter { get; } = new(1);
     [NotMapped, JsonIgnore] public double _MilliMeters { get => _Value; init => _Value = value; }
 
 

QWERTYkez.Mensura/Units/Mass.cs

@@ -6,7 +6,7 @@
 [UnitGenerator, DebuggerDisplay("gr = {_Grams.ToString(\"0.###\")}, kg = {KiloGrams.ToString(\"0.###\")}")]
 public readonly partial record struct Mass
 {
-	public static Mass Gram { get; } = new() { _Grams = 1 };
+	public static Mass _Gram { get; } = new() { _Grams = 1 };
 	[NotMapped, JsonIgnore] public double _Grams { get => _Value; init => _Value = value; }
 
 

QWERTYkez.Mensura/Units/MassPerSquare.cs

@@ -6,7 +6,7 @@
 [UnitGenerator, DebuggerDisplay("kg/m2 = {_KiloGramsPerMeterSquared.ToString(\"0.###\")}, kg/mm2 = {KiloGramsPerMilliMeterSquared.ToString(\"0.###\")}")]
 public readonly partial record struct MassPerSquare
 {
-	public static MassPerSquare KiloGramPerMeterSquared { get; } = new() { _KiloGramsPerMeterSquared = 1 };
+	public static MassPerSquare _KiloGramPerMeterSquared { get; } = new() { _KiloGramsPerMeterSquared = 1 };
 	[NotMapped, JsonIgnore] public double _KiloGramsPerMeterSquared { get => _Value; init => _Value = value; }
 
 

QWERTYkez.Mensura/Units/Pogon/.Pogon.cs

@@ -1,149 +0,0 @@
-//namespace MetricSystem;
-
-///// <summary>
-///// Base value is PerMilliMeter
-///// </summary>
-//public abstract class Pogon<T>
-//{
-
-
-//    internal T PerValue { get; init; }
-
-
-
-
-
-
-
-//    [NotMapped, JsonIgnore] internal T PerValue
-//    {
-//        get
-//        {
-//            return new()
-//            {
-//                BaseContainer = this,
-//                SilentValueSetter = Value
-//            };
-//        }
-//        set
-//        {
-//            Value = value.Value;
-//        }
-//    }
-//    [NotMapped, JsonIgnore] public T _PerMilliMeter
-//    {
-//        get
-//        {
-//            return new()
-//            {
-//                BaseContainer = this,
-//                SilentValueSetter = Value
-//            };
-//        }
-//        set
-//        {
-//            Value = value.Value;
-//        }
-//    }
-
-
-//    [NotMapped, JsonIgnore] public T PerMilliMeter
-//    {
-//        get
-//        {
-//            return new()
-//            {
-//                BaseContainer = this,
-//                SilentValueSetter = Value
-//            };
-//        }
-//        set
-//        {
-//            Value = value.Value;
-//        }
-//    }
-//    [NotMapped, JsonIgnore] public T PerCentiMeter
-//    {
-//        get
-//        {
-//            return new()
-//            {
-//                BaseContainer = this,
-//                SilentValueSetter = Value * LengthConv.CentiMeters.Multiplicator,
-//                BaseContainerMultiplicator = LengthConv.CentiMeters.Multiplicator,
-//            };
-//        }
-//        set
-//        {
-//            Value = value.Value / LengthConv.CentiMeters.Multiplicator;
-//        }
-//    }
-//    [NotMapped, JsonIgnore] public T PerDeciMeter
-//    {
-//        get
-//        {
-//            return new()
-//            {
-//                BaseContainer = this,
-//                SilentValueSetter = Value * LengthConv.DeciMeters.Multiplicator,
-//                BaseContainerMultiplicator = LengthConv.DeciMeters.Multiplicator,
-//            };
-//        }
-//        set
-//        {
-//            Value = value.Value / LengthConv.DeciMeters.Multiplicator;
-//        }
-//    }
-//    [NotMapped, JsonIgnore] public T PerMeter
-//    {
-//        get
-//        {
-//            return new()
-//            {
-//                BaseContainer = this,
-//                SilentValueSetter = Value * LengthConv.Meters.Multiplicator,
-//                BaseContainerMultiplicator = LengthConv.Meters.Multiplicator,
-//            };
-//        }
-//        set
-//        {
-//            Value = value.Value / LengthConv.Meters.Multiplicator;
-//        }
-//    }
-//    [NotMapped, JsonIgnore] public T PerKiloMeter
-//    {
-//        get
-//        {
-//            return new()
-//            {
-//                BaseContainer = this,
-//                SilentValueSetter = Value * LengthConv.KiloMeters.Multiplicator,
-//                BaseContainerMultiplicator = LengthConv.KiloMeters.Multiplicator,
-//            };
-//        }
-//        set
-//        {
-//            Value = value.Value / LengthConv.KiloMeters.Multiplicator;
-//        }
-//    }
-
-//    public static T operator *(Pogon<U, T> left, Length right) => ((U)left).Protect()._PerMilliMeter * right.Protect()._MilliMeters;
-//    public static MetricCollection<T> operator *(Pogon<U, T> left, MetricCollection<Length> right) => right.MetricSelect(r => ((U)left).Protect() * r.Protect());
-//    public static MetricArray<T> operator *(Pogon<U, T> left, MetricArray<Length> right) => right.MetricSelect(r => ((U)left).Protect() * r.Protect());
-//    public static MetricList<T> operator *(Pogon<U, T> left, MetricList<Length> right) => right.MetricSelect(r => ((U)left).Protect() * r.Protect());
-//    public static MetricObservableCollection<T> operator *(Pogon<U, T> left, MetricObservableCollection<Length> right) => right.MetricSelect(r => ((U)left).Protect() * r.Protect());
-
-
-//    public static T operator *(Length left, Pogon<U, T> right) => ((U)right).Protect()._PerMilliMeter * left.Protect()._MilliMeters;
-//    public static MetricCollection<T> operator *(MetricCollection<Length> left, Pogon<U, T> right) => left.MetricSelect(r => ((U)right).Protect() * r.Protect());
-//    public static MetricArray<T> operator *(MetricArray<Length> left, Pogon<U, T> right) => left.MetricSelect(r => ((U)right).Protect() * r.Protect());
-//    public static MetricList<T> operator *(MetricList<Length> left, Pogon<U, T> right) => left.MetricSelect(r => ((U)right).Protect() * r.Protect());
-//    public static MetricObservableCollection<T> operator *(MetricObservableCollection<Length> left, Pogon<U, T> right) => left.MetricSelect(r => ((U)right).Protect() * r.Protect());
-
-
-//    public static Length operator /(T left, Pogon<U, T> right) => new() { _MilliMeters = left.Protect() / ((U)right).Protect()._PerMilliMeter };
-//    public static MetricCollection<Length> operator *(MetricCollection<T> left, Pogon<U, T> right) => left.MetricSelect(l => l.Protect() / ((U)right).Protect());
-//    public static MetricArray<Length> operator *(MetricArray<T> left, Pogon<U, T> right) => left.MetricSelect(l => l.Protect() / ((U)right).Protect());
-//    public static MetricList<Length> operator *(MetricList<T> left, Pogon<U, T> right) => left.MetricSelect(l => l.Protect() / ((U)right).Protect());
-//    public static MetricObservableCollection<Length> operator *(MetricObservableCollection<T> left, Pogon<U, T> right) => left.MetricSelect(l => l.Protect() / ((U)right).Protect());
-//}

QWERTYkez.Mensura/Units/Pressure.cs

@@ -6,7 +6,7 @@
 [UnitGenerator, DebuggerDisplay("Pa, N/m2 = {NewtonsPerMeterSquared.ToString(\"0.###\")}, kgf/mm2 = {KiloGramForcesPerMilliMeterSquared.ToString(\"0.###\")}")]
 public readonly partial record struct Pressure
 {
-	public static Pressure Pascal { get; } = new() { _Pascals = 1 };
+	public static Pressure _Pascal { get; } = new() { _Pascals = 1 };
 	[NotMapped, JsonIgnore] public double _Pascals { get => _Value; init => _Value = value; }
 
 

QWERTYkez.Mensura/Units/Speed.cs

@@ -6,7 +6,7 @@
 [UnitGenerator, DebuggerDisplay("km/h = {_KiloMetersPerHour.ToString(\"0.###\")}, m/s = {MetersPerSecond.ToString(\"0.###\")}")]
 public readonly partial record struct Speed
 {
-    public static Speed KiloMeterPerHour { get; } = new() { _KiloMetersPerHour = 1 };
+    public static Speed _KiloMeterPerHour { get; } = new() { _KiloMetersPerHour = 1 };
     [NotMapped, JsonIgnore] public double _KiloMetersPerHour { get => _Value; init => _Value = value; }
 
 

QWERTYkez.Mensura/Units/Time.cs

@@ -6,7 +6,7 @@
 [UnitGenerator, DebuggerDisplay("ms = {_MilliSeconds.ToString(\"0.###\")}, s = {Seconds.ToString(\"0.###\")}")]
 public readonly partial record struct Time
 {
-	public static Time MilliSecond { get; } = new() { _MilliSeconds = 1 };
+	public static Time _MilliSecond { get; } = new() { _MilliSeconds = 1 };
 	[NotMapped, JsonIgnore] public double _MilliSeconds { get => _Value; init => _Value = value; }
 
 

QWERTYkez.Mensura/Units/Torque.cs

@@ -6,7 +6,7 @@
 [UnitGenerator, DebuggerDisplay("N*m = {_Newton_Meters.ToString(\"0.###\")}, kgf*m = {KiloGramForce_Meters.ToString(\"0.###\")}")]
 public readonly partial record struct Torque
 {
-	public static Torque Newton_Meter { get; } = new() { _Newton_Meters = 1 };
+	public static Torque _Newton_Meter { get; } = new() { _Newton_Meters = 1 };
 	[NotMapped, JsonIgnore] public double _Newton_Meters { get => _Value; init => _Value = value; }
 
 

QWERTYkez.Mensura/Units/Udel/.Udel.cs

@@ -1,175 +0,0 @@
-//namespace MetricSystem;
-
-///// <summary>
-///// Base value is PerMilliMeterCubic
-///// </summary>
-//[Owned]
-//public abstract class Udel<U, T> : Metric<U, Udel<U, T>>
-//    where U : Udel<U, T>, new()
-//    where T : Metric<T, T>, new()
-//{
-//    protected override void OnValueChanged()
-//    {
-//        OnPropertyChanged(nameof(PerMeter_PerMilliMeterSquared));
-//        OnPropertyChanged(nameof(PerMilliMeterCubic));
-//        OnPropertyChanged(nameof(PerCentiMeterCubic));
-//        OnPropertyChanged(nameof(PerDeciMeterCubic));
-//        OnPropertyChanged(nameof(PerMeterCubic));
-//        OnPropertyChanged(nameof(PerKiloMeterCubic));
-//    }
-
-//    [NotMapped, JsonIgnore] internal T PerValue
-//    {
-//        get
-//        {
-//            return new()
-//            {
-//                BaseContainer = this,
-//                SilentValueSetter = Value,
-//            };
-//        }
-//        set
-//        {
-//            Value = value.Value;
-//            OnPropertyChanged(nameof(PerValue));
-//        }
-//    }
-//    [NotMapped, JsonIgnore] public T _PerMilliMeterCubic
-//    {
-//        get
-//        {
-//            return new()
-//            {
-//                BaseContainer = this,
-//                SilentValueSetter = Value,
-//            };
-//        }
-//        set
-//        {
-//            Value = value.Value;
-//            OnPropertyChanged(nameof(_PerMilliMeterCubic));
-//        }
-//    }
-
-
-//    [NotMapped, JsonIgnore] public T PerMilliMeterCubic
-//    {
-//        get
-//        {
-//            return new()
-//            {
-//                BaseContainer = this,
-//                SilentValueSetter = Value,
-//            };
-//        }
-//        set
-//        {
-//            Value = value.Value;
-//            OnPropertyChanged(nameof(PerMilliMeterCubic));
-//        }
-//    }
-//    [NotMapped, JsonIgnore] public T PerMeter_PerMilliMeterSquared
-//    {
-//        get
-//        {
-//            return new()
-//            {
-//                BaseContainer = this,
-//                SilentValueSetter = Value * LengthConv.Meters.Multiplicator * Math.Pow(LengthConv.MilliMeters.Multiplicator, 2),
-//                BaseContainerMultiplicator = LengthConv.Meters.Multiplicator * Math.Pow(LengthConv.MilliMeters.Multiplicator, 2),
-//            };
-//        }
-//        set
-//        {
-//            Value = value.Value / (LengthConv.Meters.Multiplicator * Math.Pow(LengthConv.MilliMeters.Multiplicator, 2));
-//            OnPropertyChanged(nameof(PerMeter_PerMilliMeterSquared));
-//        }
-//    }
-//    [NotMapped, JsonIgnore] public T PerCentiMeterCubic
-//    {
-//        get
-//        {
-//            return new()
-//            {
-//                BaseContainer = this,
-//                SilentValueSetter = Value * Math.Pow(LengthConv.CentiMeters.Multiplicator, 3),
-//                BaseContainerMultiplicator = Math.Pow(LengthConv.CentiMeters.Multiplicator, 3),
-//            };
-//        }
-//        set
-//        {
-//            Value = value.Value / Math.Pow(LengthConv.CentiMeters.Multiplicator, 3);
-//            OnPropertyChanged(nameof(PerCentiMeterCubic));
-//        }
-//    }
-//    [NotMapped, JsonIgnore] public T PerDeciMeterCubic
-//    {
-//        get
-//        {
-//            return new()
-//            {
-//                BaseContainer = this,
-//                SilentValueSetter = Value * Math.Pow(LengthConv.DeciMeters.Multiplicator, 3),
-//                BaseContainerMultiplicator = Math.Pow(LengthConv.DeciMeters.Multiplicator, 3),
-//            };
-//        }
-//        set
-//        {
-//            Value = value.Value / Math.Pow(LengthConv.DeciMeters.Multiplicator, 3);
-//            OnPropertyChanged(nameof(PerDeciMeterCubic));
-//        }
-//    }
-//    [NotMapped, JsonIgnore] public T PerMeterCubic
-//    {
-//        get
-//        {
-//            return new()
-//            {
-//                BaseContainer = this,
-//                SilentValueSetter = Value * Math.Pow(LengthConv.Meters.Multiplicator, 3),
-//                BaseContainerMultiplicator = Math.Pow(LengthConv.Meters.Multiplicator, 3),
-//            };
-//        }
-//        set
-//        {
-//            Value = value.Value / Math.Pow(LengthConv.Meters.Multiplicator, 3);
-//            OnPropertyChanged(nameof(PerMeterCubic));
-//        }
-//    }
-//    [NotMapped, JsonIgnore] public T PerKiloMeterCubic
-//    {
-//        get
-//        {
-//            return new()
-//            {
-//                BaseContainer = this,
-//                SilentValueSetter = Value * Math.Pow(LengthConv.KiloMeters.Multiplicator, 3),
-//                BaseContainerMultiplicator = Math.Pow(LengthConv.KiloMeters.Multiplicator, 3),
-//            };
-//        }
-//        set
-//        {
-//            Value = value.Value / Math.Pow(LengthConv.KiloMeters.Multiplicator, 3);
-//            OnPropertyChanged(nameof(PerKiloMeterCubic));
-//        }
-//    }
-
-
-//    public static T operator *(Udel<U, T> left, Volume right) => ((U)left).Protect()._PerMilliMeterCubic * right.Protect()._MilliMetersCubic;
-//    public static MetricCollection<T> operator *(Udel<U, T> left, MetricCollection<Volume> right) => right.MetricSelect(r => ((U)left).Protect() * r.Protect());
-//    public static MetricArray<T> operator *(Udel<U, T> left, MetricArray<Volume> right) => right.MetricSelect(r => ((U)left).Protect() * r.Protect());
-//    public static MetricList<T> operator *(Udel<U, T> left, MetricList<Volume> right) => right.MetricSelect(r => ((U)left).Protect() * r.Protect());
-//    public static MetricObservableCollection<T> operator *(Udel<U, T> left, MetricObservableCollection<Volume> right) => right.MetricSelect(r => ((U)left).Protect() * r.Protect());
-
-//    public static T operator *(Volume left, Udel<U, T> right) => ((U)right).Protect()._PerMilliMeterCubic * left.Protect()._MilliMetersCubic;
-//    public static MetricCollection<T> operator *(MetricCollection<Volume> left, Udel<U, T> right) => left.MetricSelect(r => ((U)right).Protect() * r.Protect());
-//    public static MetricArray<T> operator *(MetricArray<Volume> left, Udel<U, T> right) => left.MetricSelect(r => ((U)right).Protect() * r.Protect());
-//    public static MetricList<T> operator *(MetricList<Volume> left, Udel<U, T> right) => left.MetricSelect(r => ((U)right).Protect() * r.Protect());
-//    public static MetricObservableCollection<T> operator *(MetricObservableCollection<Volume> left, Udel<U, T> right) => left.MetricSelect(r => ((U)right).Protect() * r.Protect());
-
-//    public static Volume operator /(T left, Udel<U, T> right) => new() { _MilliMetersCubic = left.Protect() / ((U)right).Protect()._PerMilliMeterCubic };
-//    public static MetricCollection<Volume> operator *(MetricCollection<T> left, Udel<U, T> right) => left.MetricSelect(l => l.Protect() / ((U)right).Protect());
-//    public static MetricArray<Volume> operator *(MetricArray<T> left, Udel<U, T> right) => left.MetricSelect(l => l.Protect() / ((U)right).Protect());
-//    public static MetricList<Volume> operator *(MetricList<T> left, Udel<U, T> right) => left.MetricSelect(l => l.Protect() / ((U)right).Protect());
-//    public static MetricObservableCollection<Volume> operator *(MetricObservableCollection<T> left, Udel<U, T> right) => left.MetricSelect(l => l.Protect() / ((U)right).Protect());
-//}

QWERTYkez.Mensura/Units/Voltage.cs

@@ -6,7 +6,7 @@
 [UnitGenerator, DebuggerDisplay("V = {_Volts.ToString(\"0.###\")}")]
 public readonly partial record struct Voltage
 {
-	public static Voltage Volt { get; } = new() { _Volts = 1 };
+	public static Voltage _Volt { get; } = new() { _Volts = 1 };
 	[NotMapped, JsonIgnore] public double _Volts { get => _Value; init => _Value = value; }
 
 

QWERTYkez.Mensura/Units/Volume.cs

@@ -6,7 +6,7 @@
 [UnitGenerator, DebuggerDisplay("mm3 = {_MilliMetersCubic.ToString(\"0.###\")}, m3 = {MetersCubic.ToString(\"0.###\")}")]
 public readonly partial record struct Volume
 {
-	public static Volume MilliMeterCubic { get; } = new() { _MilliMetersCubic = 1 };
+	public static Volume _MilliMeterCubic { get; } = new() { _MilliMetersCubic = 1 };
 	[NotMapped, JsonIgnore] public double _MilliMetersCubic { get => _Value; init => _Value = value; }
 
 

QWERTYkez.Mensura/globals.cs

@@ -13,4 +13,3 @@ global using System.Text.Json.Serialization;
 global using QWERTYkez.Mensura;
 global using QWERTYkez.Mensura.Extensions;
 global using QWERTYkez.Mensura.Units;
-global using QWERTYkez.Mensura.Units.Complex;