Merge pull request #20 from PandaTechAM/development

Extreme performance boost with backward compatability

Author: HaikAsatryan

Readme.md

@@ -23,7 +23,8 @@ period validations remain precise and reliable.
 - **Configurable** - The library is highly configurable, allowing you to define your own commission ranges and
   commission types.
 - **Robust Testing** - Achieves 99% code coverage, ensuring reliability.
-- **Optimized Performance** - Delivers high performance, capable of over 1.5 million calculations per second.
+- **Optimized Performance** - Delivers high performance, capable of over 5 million calculations per second with 0 ram
+  allocation.
 
 ## 1.3. Installation
 

src/CommissionCalculator/Commission.cs

@@ -1,146 +1,80 @@
 using CommissionCalculator.DTO;
+using CommissionCalculator.Internal;
+using static CommissionCalculator.Internal.FastPath;
 
 namespace CommissionCalculator;
 
 public static class Commission
 {
-   private const decimal DecimalEpsilon = 1e-28M; //smallest decimal value that is greater than zero
-
+   // Principal-based
    public static decimal ComputeCommission(decimal principalAmount, CommissionRule rule)
    {
-      decimal commission;
-
-      if (rule.CalculationType == CalculationType.Proportional)
-      {
-         commission = CalculateProportionalCommission(principalAmount, rule);
-         return Math.Round(commission, rule.DecimalPlace);
-      }
-
-      commission = CalculateAbsoluteCommission(principalAmount, rule);
-      return Math.Round(commission, rule.DecimalPlace);
-   }
-
-   private static decimal CalculateAbsoluteCommission(decimal principalAmount, CommissionRule rule)
-   {
-      rule = ConvertCommissionRanges(rule);
+      var nr = CommissionRuleCache.Get(rule);
 
-      var range = rule.CommissionRangeConfigs.FirstOrDefault(r =>
-         principalAmount >= r.RangeStart && principalAmount < r.RangeEnd);
+      var commission = nr.CalcType == CalculationType.Proportional
+         ? CalculateProportional(principalAmount, nr)
+         : CalculateAbsolute(principalAmount, nr);
 
-      return ComputeRangeCommission(range!.Type,
-         range.CommissionAmount,
-         range.MinCommission,
-         range.MaxCommission,
-         principalAmount);
+      return Math.Round(commission, nr.DecimalPlaces);
    }
 
+   // Selector-based (selector chooses range; commission is applied to principal)
    public static decimal ComputeCommission(decimal principalAmount, decimal selectorValue, CommissionRule rule)
    {
-      if (rule.CalculationType == CalculationType.Proportional)
+      var nr = CommissionRuleCache.Get(rule);
+      if (nr.CalcType == CalculationType.Proportional)
       {
          throw new InvalidOperationException(
             "Selector-based overload is incompatible with Proportional rules. Use Absolute.");
       }
 
-      var converted = ConvertCommissionRanges(rule);
+      var idx = FindRangeIndex(nr, selectorValue);
+      var r = nr.Ranges[idx];
 
-      var range = converted.CommissionRangeConfigs.FirstOrDefault(r =>
-         selectorValue >= r.RangeStart && selectorValue < r.RangeEnd);
+      var commission = ComputeRangeCommission(r.Type, r.Amount, r.Min, r.Max, principalAmount);
+      return Math.Round(commission, nr.DecimalPlaces);
+   }
 
-      var commission = ComputeRangeCommission(
-         range!.Type,
-         range.CommissionAmount,
-         range.MinCommission,
-         range.MaxCommission,
-         principalAmount
-      );
+   // ===== Fast paths using normalized rules =====
 
-      return Math.Round(commission, converted.DecimalPlace);
+   private static decimal CalculateAbsolute(decimal principalAmount, NormalizedCommissionRule nr)
+   {
+      var idx = FindRangeIndex(nr, principalAmount);
+      var r = nr.Ranges[idx];
+      return ComputeRangeCommission(r.Type, r.Amount, r.Min, r.Max, principalAmount);
    }
 
-   private static decimal CalculateProportionalCommission(decimal principalAmount, CommissionRule rule)
+   private static decimal CalculateProportional(decimal principalAmount, NormalizedCommissionRule nr)
    {
-      rule = ConvertCommissionRanges(rule);
+      // Find the current tier
+      var idx = FindRangeIndex(nr, principalAmount);
+      var r = nr.Ranges[idx];
 
-      decimal commission = 0;
+      // Sum of fully completed prior tiers
+      var sum = nr.ProportionalPrefix.Length == 0 ? 0 : nr.ProportionalPrefix[idx];
 
+      // Partial of the current tier
+      var portion = principalAmount - r.Start;
+      sum += ComputeRangeCommission(r.Type, r.Amount, r.Min, r.Max, portion);
 
-      foreach (var range in rule.CommissionRangeConfigs)
-      {
-         if (principalAmount >= range.RangeStart && principalAmount < range.RangeEnd)
-         {
-            var portionOfPrincipal = principalAmount - range.RangeStart;
-
-            commission += ComputeRangeCommission(range.Type,
-               range.CommissionAmount,
-               range.MinCommission,
-               range.MaxCommission,
-               portionOfPrincipal);
-         }
-
-         if (principalAmount < range.RangeEnd)
-         {
-            continue;
-         }
-
-         {
-            var portionOfPrincipal = range.RangeEnd - range.RangeStart - DecimalEpsilon;
-
-            commission += ComputeRangeCommission(range.Type,
-               range.CommissionAmount,
-               range.MinCommission,
-               range.MaxCommission,
-               portionOfPrincipal);
-         }
-      }
-
-      return commission;
+      return sum;
    }
 
-   private static decimal ComputeRangeCommission(CommissionType commissionType,
-      decimal commission,
-      decimal minimum,
-      decimal maximum,
-      decimal principalAmount)
+   // ===== Validation (public contract) =====
+
+   public static bool ValidateRule(CommissionRule rule)
    {
-      if (commissionType == CommissionType.FlatRate)
+      try
       {
-         return commission;
+         ValidateCommissionRule(rule);
+         return true;
       }
-
-      var computedCommission = principalAmount * commission;
-      if (computedCommission < minimum)
+      catch
       {
-         return minimum;
+         return false;
       }
-
-      return computedCommission > maximum ? maximum : computedCommission;
-   }
-
-   private static CommissionRule ConvertCommissionRanges(CommissionRule rule)
-   {
-      ValidateCommissionRule(rule);
-
-      var convertedRanges = rule.CommissionRangeConfigs
-                                .Select(c => new CommissionRangeConfigs
-                                {
-                                   RangeStart = c.RangeStart,
-                                   RangeEnd = c.RangeEnd == 0 ? decimal.MaxValue : c.RangeEnd,
-                                   Type = c.Type,
-                                   CommissionAmount = c.CommissionAmount,
-                                   MinCommission = c.MinCommission,
-                                   MaxCommission = c.MaxCommission == 0 ? decimal.MaxValue : c.MaxCommission
-                                })
-                                .ToList();
-      return new CommissionRule
-      {
-         CalculationType = rule.CalculationType,
-         DecimalPlace = rule.DecimalPlace,
-         CommissionRangeConfigs = convertedRanges
-      };
    }
 
-
    private static void ValidateCommissionRule(CommissionRule rule)
    {
       if (rule == null || rule.CommissionRangeConfigs.Count == 0)
@@ -157,21 +91,21 @@ private static void ValidateCommissionRule(CommissionRule rule)
 
       if (rule.CommissionRangeConfigs.Count == 1)
       {
-         if (rule.CommissionRangeConfigs[0].RangeStart != 0 || rule.CommissionRangeConfigs[0].RangeEnd != 0)
+         var only = rule.CommissionRangeConfigs[0];
+         if (only.RangeStart != 0 || only.RangeEnd != 0)
          {
             throw new InvalidOperationException("In case of one range, both 'From' and 'To' should be 0.");
          }
 
-         if (rule.CommissionRangeConfigs[0].MaxCommission != 0 && rule.CommissionRangeConfigs[0].MaxCommission <
-             rule.CommissionRangeConfigs[0].MinCommission)
+         if (only.MaxCommission != 0 && only.MaxCommission < only.MinCommission)
          {
             throw new InvalidOperationException("MaxCommission should be greater than or equal to MinCommission.");
          }
+
+         return;
       }
-      else
-      {
-         ValidateEachRange(rule);
-      }
+
+      ValidateEachRange(rule);
    }
 
    private static void ValidateEachRange(CommissionRule rule)
@@ -188,7 +122,6 @@ private static void ValidateEachRange(CommissionRule rule)
       }
 
       var verifiedRules = 1;
-
       var lastTo = startRule.RangeEnd;
 
       while (true)
@@ -215,7 +148,6 @@ private static void ValidateEachRange(CommissionRule rule)
          }
 
          verifiedRules++;
-
          lastTo = nextRule!.RangeEnd;
       }
 
@@ -224,17 +156,4 @@ private static void ValidateEachRange(CommissionRule rule)
          throw new InvalidOperationException("There is some nested or gap ranges in the rules.");
       }
    }
-
-   public static bool ValidateRule(CommissionRule rule)
-   {
-      try
-      {
-         ValidateCommissionRule(rule);
-         return true;
-      }
-      catch (Exception)
-      {
-         return false;
-      }
-   }
 }

src/CommissionCalculator/CommissionCalculator.csproj

@@ -7,14 +7,14 @@
         <PackageIcon>pandatech.png</PackageIcon>
         <PackageReadmeFile>Readme.md</PackageReadmeFile>
         <Copyright>MIT</Copyright>
-        <Version>4.0.2</Version>
+        <Version>4.1.0</Version>
         <Authors>Pandatech</Authors>
         <PackageId>Pandatech.CommissionCalculator</PackageId>
         <Title>Pandatech.CommissionCalculator</Title>
         <PackageTags>Pandatech, library, calculator, commission, fee, bank, fintech</PackageTags>
         <Description>PandaTech.CommissionCalculator is a .NET library simplifying common fintech commission calculations.</Description>
         <RepositoryUrl>https://github.com/PandaTechAM/be-lib-commission-calculator.git</RepositoryUrl>
-        <PackageReleaseNotes>Nuget updates and new overload added</PackageReleaseNotes>
+        <PackageReleaseNotes>Extreme performance boost with backward compatability</PackageReleaseNotes>
     </PropertyGroup>
     <ItemGroup>
         <None Include="..\..\pandatech.png" Pack="true" PackagePath="\"/>

src/CommissionCalculator/Helper/DateTimeOverlapChecker.cs

@@ -6,18 +6,7 @@ public static class DateTimeOverlapChecker
 {
    public static bool HasOverlap(List<DateTimePair> firstPairs, List<DateTimePair> secondPairs)
    {
-      foreach (var firstPair in firstPairs)
-      {
-         foreach (var secondPair in secondPairs)
-         {
-            if (IsOverlapping(firstPair, secondPair))
-            {
-               return true;
-            }
-         }
-      }
-
-      return false;
+      return firstPairs.Any(firstPair => secondPairs.Any(secondPair => IsOverlapping(firstPair, secondPair)));
    }
 
    private static bool IsOverlapping(DateTimePair firstPair, DateTimePair secondPair)

src/CommissionCalculator/Internal/CommissionRuleCache.cs

@@ -0,0 +1,58 @@
+using System.Runtime.CompilerServices;
+using CommissionCalculator.DTO;
+
+namespace CommissionCalculator.Internal;
+
+internal static class CommissionRuleCache
+{
+   private static readonly ConditionalWeakTable<CommissionRule, NormalizedCommissionRule> Cache = new();
+
+   public static NormalizedCommissionRule Get(CommissionRule rule) => Cache.GetValue(rule, Normalize);
+
+   private static NormalizedCommissionRule Normalize(CommissionRule rule)
+   {
+      // Reuse public validation contract (throws if invalid)
+      if (!Commission.ValidateRule(rule))
+      {
+         throw new ArgumentException("Invalid commission rule.");
+      }
+
+      // Convert once: map 0 => +∞ for RangeEnd/Max, then sort by Start
+      var src = rule.CommissionRangeConfigs;
+      var list = new List<NormalizedRange>(src.Count);
+      foreach (var c in src)
+      {
+         var end = c.RangeEnd == 0 ? decimal.MaxValue : c.RangeEnd;
+         var max = c.MaxCommission == 0 ? decimal.MaxValue : c.MaxCommission;
+         list.Add(new NormalizedRange(c.RangeStart, end, c.Type, c.CommissionAmount, c.MinCommission, max));
+      }
+
+      list.Sort((a, b) => a.Start.CompareTo(b.Start));
+      var ranges = list.ToArray();
+
+      // Precompute proportional prefix (full-range contributions). Last +∞ contributes 0 (never fully consumed).
+      decimal[] prefix;
+      if (rule.CalculationType == CalculationType.Proportional)
+      {
+         prefix = new decimal[ranges.Length + 1];
+         for (var i = 0; i < ranges.Length; i++)
+         {
+            var r = ranges[i];
+            if (r.End == decimal.MaxValue)
+            {
+               prefix[i + 1] = prefix[i];
+               continue;
+            }
+
+            var width = r.End - r.Start; // finite
+            prefix[i + 1] = prefix[i] + FastPath.ComputeRangeCommission(r.Type, r.Amount, r.Min, r.Max, width);
+         }
+      }
+      else
+      {
+         prefix = [];
+      }
+
+      return new NormalizedCommissionRule(rule.CalculationType, rule.DecimalPlace, ranges, prefix);
+   }
+}