Simulation of Realistic Sensor Data

public class Simulator
{
    private readonly float _mean;
    private readonly float _standardDeviation;
    private readonly float _stepSizeFactor
    private double _value;
    private readonly float _defaultErrorRate;
    private readonly float _defaultErrorLength;
    private float _currentErrorRate;
    private float _currentErrorLength;
    private readonly float _minimum;
    private readonly float _maximum;
    private bool _isCurrentError;
    // we use the _lastNoneErrorValue variable to reset to this value
    // after the error state ends
    private double _lastNoneErrorValue;
    private static readonly List<int> Factors = new(){-1, 1};
    private readonly Random _random;
    // we use the following variables to keep track how many errors we 
    // encountered
    public int ValueCount { get; private set; }
    public int ErrorCount { get; private set; }

    public Simulator(int seed, 
                     float mean, 
                     float standardDeviation, 
                     float errorRate = 0f, 
                     float errorLength = 0f, 
                     float minimum = float.MinValue, 
                     float maximum = float.MaxValue)
    {
        _random = new Random(seed);
        _mean = mean;
        _standardDeviation = Math.Abs(standardDeviation);
        _stepSizeFactor = _standardDeviation / 10;
        // we use default and current error variables to reset the values
        // after the error state ends
        _defaultErrorRate = errorRate;
        _defaultErrorLength = errorLength;
        _currentErrorRate = errorRate;
        _currentErrorLength = errorLength;
        _minimum = minimum;
        _maximum = maximum;
        // initially we mark our state as no current error
        _isCurrentError = false;
        _value = _mean - _random.NextDouble();
    }
}

public double CalculateNextValue()
{
    // first we need to figure out if we are in a state of error and adjust the values 
    // accordinglyif (_isCurrentError)
    {
        _currentErrorLength -= 1;
        _currentErrorRate = _currentErrorLength;
        if (_currentErrorRate < 0.01)
        {
            _currentErrorRate = 0.01f;
        }
    }

    // we calculate if the next value will be an error
    bool nextIsError = _random.NextDouble() < _currentErrorRate;

    // if not we calculate a new value and if the previous value has been an error
    // we reset the error variables
    // otherwise we save the _lastNoneErrorValue and calculate a new error value
    if (!nextIsError)
    {
        NewValue();
        if (_isCurrentError)
        {
            _isCurrentError = false;
            _currentErrorRate = _defaultErrorRate;
            _currentErrorLength = _defaultErrorLength;
        }
    }
    else
    {
        if (!_isCurrentError)
        {
            _lastNoneErrorValue = _value;
        }
        NewErrorValue();
    }

    return _value;
}

private void NewValue()
{
    // we increase the count of none error values
    ValueCount += 1;

    double valueChange = _random.NextDouble() * _stepSizeFactor;
    int factor = Factors[DecideFactor()];

    // if the previous value has been an error, we don't take the last value but
    // the _lastNoneErrorValue as basis for the new value
    if (_isCurrentError)
    {
        _value = _lastNoneErrorValue + (valueChange * factor);
    }
    else
    {
        _value += valueChange * factor;
    }
}

private void NewErrorValue()
{
    // we increase the count of error values
    ErrorCount += 1;

    // if the previous value has not been an error we calculate a new error value 
    // in the set boundaries otherwise we calculate a new value based on the 
    // previous error value.
    if (!_isCurrentError)
    {
        if (_value < _mean)
        {
            _value = _random.NextDouble() * (_mean - 3 * _standardDeviation - _minimum) + _minimum;
        }
        else
        {
            _value = _random.NextDouble() * (_maximum - _mean - 3 * _standardDeviation) + _mean + _standardDeviation;
        }
        _isCurrentError = true;
    }
    else
    {
        double valueChange = _random.NextDouble() * _stepSizeFactor;
        _value += valueChange * Factors[_random.Next(0, 1)];
    }
}

List<double> dataSet = new List<double>();
Simulator sim = new Simulator(seed: 12345, mean: 20, standardDeviation: 5, errorRate: 0.01f, errorLength: 4.21f, min: 0, max: 40);

for(int i = 0; i < 1000; i++)
{
    dataSet.Add(sim.CalculateNextValue);
}