IMensuraUnit<U>

QWERTYkez.Mensura.Generator/ComplexUnitGenerator.cs

@@ -195,7 +195,7 @@ using System.Runtime.Serialization;
 namespace QWERTYkez.Mensura.Units;
 
 [JsonConverter(typeof(UnitJsonConverter<{typeNameZ}>))]
-public readonly partial record struct {typeNameZ} : IMensuraUnit<{typeNameZ}>, IEquatable<{typeNameZ}>, IMensuraUnit
+public readonly partial record struct {typeNameZ} : IEquatable<{typeNameZ}>, IMensuraUnit, IMensuraUnit<{typeNameZ}>
 {
 
     [JsonInclude, DataMember, JsonPropertyName(""v""), Obsolete] // для JSON / EF на случай сбоев, если пробелма с _Value
@@ -212,6 +212,16 @@ public readonly partial record struct {typeNameZ} : IMensuraUnit<{typeNameZ}>, I
     public static explicit operator double({typeNameZ} unit) => unit._Value;
 
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public {typeNameZ} Abs() => new(Math.Abs(_Value));
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal R Pow2_Internal<R>() where R : struct, IMensuraUnit, IEquatable<R> => (_Value * _Value).ToUnit<R>();
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal R Sqrt_Internal<R>() where R : struct, IMensuraUnit, IEquatable<R> => Math.Sqrt(_Value).ToUnit<R>();
+
+
     [JsonIgnore, IgnoreDataMember] public bool IsPositive => _Value >= 0;
     [JsonIgnore, IgnoreDataMember] public bool IsGreaterThanZero => _Value > 0;
     [JsonIgnore, IgnoreDataMember] public bool IsNegative => double.IsNegative(_Value);

QWERTYkez.Mensura.Generator/UnitGenerator.cs

@@ -144,7 +144,7 @@ using System.Runtime.Serialization;
 namespace QWERTYkez.Mensura.Units;
 
 [JsonConverter(typeof(UnitJsonConverter<{typeName}>))]
-public readonly partial record struct {typeName} : IMensuraUnit<{typeName}>, IEquatable<{typeName}>, IMensuraUnit
+public readonly partial record struct {typeName} : IEquatable<{typeName}>, IMensuraUnit, IMensuraUnit<{typeName}>
 {
     [JsonInclude, DataMember, JsonPropertyName(""v""), Obsolete] // для JSON / EF на случай сбоев, если пробелма с _Value
     internal double Value { get => _Value; init => _Value = value; }

QWERTYkez.Mensura/IMensuraUnit.cs

@@ -1,5 +1,19 @@
 namespace QWERTYkez.Mensura;
 
-internal interface IMensuraUnit { }
+public interface IMensuraUnit
+{
+    [JsonIgnore, IgnoreDataMember] public bool IsPositive { get; }
+    [JsonIgnore, IgnoreDataMember] public bool IsGreaterThanZero { get; }
+    [JsonIgnore, IgnoreDataMember] public bool IsNegative { get; }
+    [JsonIgnore, IgnoreDataMember] public bool IsZero { get; }
+    [JsonIgnore, IgnoreDataMember] public bool IsNaN { get; }
+    [JsonIgnore, IgnoreDataMember] public bool IsFinite { get; }
+    [JsonIgnore, IgnoreDataMember] public bool IsInfinity { get; }
+    [JsonIgnore, IgnoreDataMember] public bool IsPositiveInfinity { get; }
+    [JsonIgnore, IgnoreDataMember] public bool IsNegativeInfinity { get; }
+}
 
-internal interface IMensuraUnit<U> where U : struct, IMensuraUnit, IEquatable<U> { }
+internal interface IMensuraUnit<U> where U : struct, IMensuraUnit, IEquatable<U>
+{
+    public U Abs();
+}

QWERTYkez.Mensura/Operators.cs

@@ -3,15 +3,15 @@
 internal static class Coefficients
 {
     internal static double MultiplyCoefficient<T1, T2, TResult>(T1 a, T2 b, TResult r)
-        where T1 : struct, IMensuraUnit<T1>, IEquatable<T1>, IMensuraUnit
+        where T1 : struct, IEquatable<T1>, IMensuraUnit
-        where T2 : struct, IMensuraUnit<T2>, IEquatable<T2>, IMensuraUnit
+        where T2 : struct, IEquatable<T2>, IMensuraUnit
-        where TResult : struct, IMensuraUnit<TResult>, IEquatable<TResult>, IMensuraUnit
+        where TResult : struct, IEquatable<TResult>, IMensuraUnit
         => r.ToDouble() / (a.ToDouble() * b.ToDouble());
 
     internal static double DivideCoefficient<T1, T2, TResult>(T1 a, T2 b, TResult r)
-        where T1 : struct, IMensuraUnit<T1>, IEquatable<T1>, IMensuraUnit
+        where T1 : struct, IEquatable<T1>, IMensuraUnit
-        where T2 : struct, IMensuraUnit<T2>, IEquatable<T2>, IMensuraUnit
+        where T2 : struct, IEquatable<T2>, IMensuraUnit
-        where TResult : struct, IMensuraUnit<TResult>, IEquatable<TResult>, IMensuraUnit
+        where TResult : struct, IEquatable<TResult>, IMensuraUnit
         => r.ToDouble() * b.ToDouble() / a.ToDouble();
 }
 
@@ -70,6 +70,10 @@ public readonly partial record struct Area // MilliMetersSquared
     internal static readonly double Coeff1 = Coefficients.MultiplyCoefficient(Area.MeterSquared, ForceLinear.NewtonPerMeter, Torque._Newton_Meter);
 
     [MethodImpl(MethodImplOptions.NoInlining), OperatorsGenerator] public static Length operator /(Area left, Length right) => new(left._Value / right._Value);
+
+
+    [MethodImpl(MethodImplOptions.NoInlining), OperatorsGenerator] public static ForceVolumetric operator /(ForceLinear left, Area right) => new(left._Value / right._Value);
+    [MethodImpl(MethodImplOptions.NoInlining), OperatorsGenerator] public static Density operator /(MassLinear left, Area right) => new(left._Value / right._Value);
 }
 
 public readonly partial record struct Volume // MillimetersCubic

QWERTYkez.Mensura/Units/Complex/.LinearXXXXXXXX.Gen.cs

@@ -258,7 +258,7 @@
 //namespace QWERTYkez.Mensura.Units.Pogon
 //{
 //    [JsonConverter(typeof(PogonAAAAAAAAAAAAAAAAConverter))]
-//    public readonly partial record struct ZZZZZZZZZZZZZZZZ : IMensuraUnit<ZZZZZZZZZZZZZZZZ>, IEquatable<ZZZZZZZZZZZZZZZZ>, IMensuraUnit
+//    public readonly partial record struct ZZZZZZZZZZZZZZZZ : IEquatable<ZZZZZZZZZZZZZZZZ>, IMensuraUnit
 //    {
 
 //        [JsonInclude, DataMember, JsonPropertyName("v"), Obsolete] // для JSON / EF на случай сбоев, если пробелма с _Value

QWERTYkez.Mensura/Units/XXXXXXXX.Gen.cs

@@ -1,7 +1,7 @@
 //namespace QWERTYkez.Mensura.Units;
 
 //[JsonConverter(typeof(UnitJsonConverter<XXXXXXXX>))]
-//public readonly partial record struct XXXXXXXX : IMensuraUnit<XXXXXXXX>, IEquatable<XXXXXXXX>, IMensuraUnit
+//public readonly partial record struct XXXXXXXX : IEquatable<XXXXXXXX>, IMensuraUnit
 //{
 //    [JsonInclude, DataMember, JsonPropertyName("v"), Obsolete] // для JSON / EF на случай сбоев, если пробелма с _Value
 //    internal double Value { get => _Value; init => _Value = value; }