Nominal Size

NominalSize.cs

using System;
using System.Linq;
using static System.Math;

namespace NominalSize
{
    public sealed class Size
    {
        public Size(decimal basicValue, decimal upperTolerance, decimal lowerTolerance)
        {
            BasicValue = basicValue;

            if (upperTolerance == lowerTolerance)
            {
                throw new ArgumentException(nameof(lowerTolerance), "Upper tolerance must differ from lower tolerance.");
            }

            if (lowerTolerance > upperTolerance)
            {
                UpperTolerance = lowerTolerance;
                LowerTolerance = upperTolerance;
            }
            else
            {
                UpperTolerance = upperTolerance;
                LowerTolerance = lowerTolerance;
            }
        }

        /// <summary>
        /// Nennmaß
        /// </summary>
        public decimal BasicValue { get; }

        /// <summary>
        /// Sollmaß
        /// </summary>
        public decimal NominalValue => (LowerDimension + UpperDimension) / 2.0m;

        public decimal UpperDimension => BasicValue + UpperTolerance;

        public decimal LowerDimension => BasicValue + LowerTolerance;

        public decimal UpperTolerance { get; }

        public decimal LowerTolerance { get; }

        public static Size operator +(Size left, Size right)
        {
            var newBasicValue = left.BasicValue + right.BasicValue;
            var newUpperTolerance = left.UpperTolerance + right.UpperTolerance;
            var newLowerTolerance = left.LowerTolerance + right.LowerTolerance;

            return new Size(newBasicValue, newUpperTolerance, newLowerTolerance);
        }

        public static Size operator -(Size left, Size right)
        {
            var newBasicValue = left.BasicValue - right.BasicValue;
            
            var newUpperTolerance = Max(left.UpperTolerance - right.UpperTolerance, left.UpperTolerance - right.LowerTolerance);
            var newLowerTolerance = Min(left.LowerTolerance - right.LowerTolerance, left.LowerTolerance - right.UpperTolerance);

            return new Size(newBasicValue, newUpperTolerance, newLowerTolerance);
        }

        public static Size operator *(Size left, Size right)
        {
            var newBasicValue = left.BasicValue * right.BasicValue;
            
            var newDimensions = new []
            {
                left.UpperDimension * right.UpperDimension,
                left.UpperDimension * right.LowerDimension, 
                left.LowerDimension * right.UpperDimension, 
                left.LowerDimension * right.LowerDimension  
            };

            var upperDimension = newDimensions.Max();
            var lowerDimension = newDimensions.Min();

            return new Size(newBasicValue, upperDimension - newBasicValue, lowerDimension - newBasicValue);
        }

        public static Size operator /(Size left, Size right)
        {
            var newBasicValue = left.BasicValue / right.BasicValue;

            var newDimensions = new []
            {
                left.UpperDimension / right.UpperDimension,
                left.UpperDimension / right.LowerDimension,
                left.LowerDimension / right.UpperDimension,
                left.LowerDimension / right.LowerDimension
            };

            var upperDimension = newDimensions.Max();
            var lowerDimension = newDimensions.Min();

            return new Size(newBasicValue, upperDimension - newBasicValue, lowerDimension - newBasicValue);
        }

        private static decimal Pow(decimal @base, decimal exponent)
        {
            return (decimal) Math.Pow((double) @base, (double) exponent);
        }

        public static Size Power(Size @base, Size exponent)
        {
            var newBasicValue = Pow(@base.BasicValue, exponent.BasicValue);

            var newDimensions = new[]
            {
                Pow(@base.UpperDimension, exponent.UpperDimension),
                Pow(@base.UpperDimension, exponent.LowerDimension),
                Pow(@base.LowerDimension, exponent.UpperDimension),
                Pow(@base.LowerDimension, exponent.LowerDimension)
            };

            var upperDimension = newDimensions.Max();
            var lowerDimension = newDimensions.Min();

            return new Size(newBasicValue, upperDimension - newBasicValue, lowerDimension - newBasicValue);
        }

    }
}