根据百分比变化修改数字

Question

我正在尝试根据可用供应量创建价格。例如，如果我们有 4000 万的商品库存，底价为 20 美元，我需要当供应量每上升 0.125% 时价格下降 0.06%，每变化 0.125% 时价格上升 0.1%供应量下降。

这是我到目前为止所能想到的......

 public void AddDailyCrudeOil() {
      CrudeOilSupplyRussia += DailyCrudeOilAmountRussia;
      /* 
       * Every 0.125% increase in supply, has a 0.06% decrease in the price. 
       * Conversely, any 0.125% decrease in supply, has a 0.1% increase in price. 
       * At our base supply, 40M, 0.125% will be 50K, and the condition will be true as our daily supply delivery is 100k
       * */
      if (DailyCrudeOilAmountRussia > CrudeOilSupplyRussia * 0.00125f) {
          CrudeOilPriceRussia *= -0.0006f;
      }
  }

但是，当然，这只会工作一次，而不是渐进式的。

我被困在这个问题上的时间比我想承认的要长，非常欢迎任何指导。

Answer 1

这样的？编写为 NUnit 测试并使用“应该”进行断言，这通过了。请注意，我使用小数来避免任何奇怪的舍入问题。

[TestFixture]
public class tmp
{
    [Test]
    public void test()
    {
        var baseAmount = 40000000M;
        var basePrice = 100;
        var percentIncreaseTrigger = 0.00125M;
        var percentDecreaseInPrice = 0.0006M;

        GetNewPrice(baseAmount, basePrice, percentIncreaseTrigger,
                    percentDecreaseInPrice, 40050000)
            .ShouldBe(99.94M);

        GetNewPrice(baseAmount, basePrice, percentIncreaseTrigger, 
                    percentDecreaseInPrice, 40100000)
            .ShouldBe(99.88M);

        GetNewPrice(baseAmount, basePrice, percentIncreaseTrigger, 
                    percentDecreaseInPrice, 40400000)
            .ShouldBe(99.52M);

    }

    private decimal GetNewPrice(decimal baseAmount, decimal basePrice, 
           decimal trigger, decimal decreaseBy, decimal newAmount)
    {
        //work out what the trigger % is as an absolute amount
        var triggerAmount = baseAmount * trigger;

        //work out the price decrease as an absolute amount of the base price
        var priceDecreaseAmount = basePrice * decreaseBy;

        //work out how much over the baseAmount we are
        var amountOver = newAmount - baseAmount;

        //work out how many times we can fit the 0.125% into this - 
        //ignore fractional parts
        var numberOfTriggers = Math.Floor(amountOver / triggerAmount);

        //multiply the priceDecrease amount up by this
        var totalToTakeOffPrice = priceDecreaseAmount * numberOfTriggers;

        var result = basePrice - totalToTakeOffPrice;

        return result;

    }
}

Answer 2

这个应该可以解决问题

public double practicalCase(double actualStock, double baseStock, double percentChange, double basePrice,
        double priceDecrease, double priceIncrease)
    {
        double changeAmount = baseStock * percentChange;
        double priceChanges = Math.Floor(Math.Abs(baseStock - actualStock) / changeAmount);

        if (actualStock > baseStock)
            return (basePrice - (priceDecrease * priceChanges));
        else
            return (basePrice + (priceIncrease * priceChanges));
    }

尝试了以下案例

    [Fact]
    public void TestPracticalCase()
    {
        Assert.Equal(100d, _propertyManager.practicalCase(actualStock: 40000000d, baseStock: 40000000d, percentChange: 0.00125d,
            basePrice: 100d, priceDecrease: 0.06d, priceIncrease: 0.1d));

        Assert.Equal(99.94d, _propertyManager.practicalCase(actualStock: 40050000d, baseStock: 40000000d, percentChange: 0.00125d,
            basePrice: 100d, priceDecrease: 0.06d, priceIncrease: 0.1d));

        Assert.Equal(101d, _propertyManager.practicalCase(actualStock: 39500000d, baseStock: 40000000d, percentChange: 0.00125d,
            basePrice: 100d, priceDecrease: 0.06d, priceIncrease: 0.1d));
    }

Answer 3

我会做一个线性函数，对于任何供应，它都会返回正确的价格。这为您提供了一个连续的价格函数，对于每 0.125% 的供应增加没有“阶梯”。如果您需要这些步骤，请忽略此答案。

根据您的要求，您可能需要 2 个公式。一个用于 4000 万以上的供应，一个用于以下，因为它们看起来有不同的斜率。但是，您真的想要 4000 万供应量的价格曲线出现“拐点”吗？

  static void Main()
  {
        var price = GetPrice(40050000.0);
        Console.WriteLine(price);
  }

  private static double GetPrice(double supply)
  {
            if (supply > 40000000.0)
            {
                 double slope = -0.012 / 50000.0; // Decrease price by 0.012 for each 50000 increase in supply
                 double origin = 20 - (slope * 40000000.0); // Calculate the price at 0 supply given the price at 40 million supply
                 return origin + supply * slope; // Price at the given supply
            }
            else
            {
                 double slope = -0.02 / 50000.0; // Decrease price by 0.02 for each 50000 increase in supply
                 double origin = 20 - (slope * 40000000.0); // Calculate the price at 0 supply given the price at 40 million supply
                 return origin + supply * slope; // Price at the given supply
            }
  }