Welcome to the Lounge

public class MyNumber {
    private object _value;
    public object Value {
        get { return _value; }
        set {
            if ((value is int) || (value is double) || (value is decimal))
                _value = value;
            else throw new InvalidCastException();
        }
    }

    public MyNumber(object val) {
        Value = val;
    }

    public static implicit operator MyNumber(int val) { return new MyNumber(val); }

    public static implicit operator int(MyNumber val) { return (int)val._value; }

    public static implicit operator MyNumber(double val) { return new MyNumber(val); }

    public static implicit operator double(MyNumber val) { return (double)val._value; }

    public static implicit operator MyNumber(decimal val) { return new MyNumber(val); }

    public static implicit operator decimal(MyNumber val) { return (decimal)val._value; }
}

public class MovingAverage {
    private LinkedList<MyNumber> _samples = new LinkedList<MyNumber>();
    private decimal total = 0;
    public int SampleSize { get; private set; }
    public decimal Value {
        get {
            if (SampleSize < 0) return (_samples.Count > 0) ? total / _samples.Count : 0;
            return (_samples.Count >= SampleSize) ? total / (decimal)SampleSize : 0;
        }
    }

    public MovingAverage(int sampleSize = -1) {
        SampleSize = sampleSize;
    }

    public void Add(MyNumber value)
    {
        _samples.AddLast(value);
        total += value;
        if (SampleSize > 0) {
            while (_samples.Count > SampleSize) {
                total -= _samples.First;
                _samples.RemoveFirst();
            }
        }
    }
}

Gary Wheeler wrote:

Everyone has their own workflow that's best for them.

OriginalGriff wrote:

SVN/GIT

public static class GenericOperator<T>
{
    private static Func<T, T, TResult> CreateCore<TResult>(Func<Expression, Expression, BinaryExpression> body)
    {
        try
        {
            Type typeT = typeof(T);
            var left = Expression.Parameter(typeT, "left");
            var right = Expression.Parameter(typeT, "right");
 
            if (typeT.IsEnum)
            {
                Type enumType = Enum.GetUnderlyingType(typeT);
                var x = Expression.Convert(left, enumType);
                var y = Expression.Convert(right, enumType);
 
                Expression op = body(x, y);
                if (op.Type == enumType) op = Expression.Convert(op, typeT);
 
                return Expression.Lambda<Func<T, T, TResult>>(op, left, right).Compile();
            }
 
            return Expression.Lambda<Func<T, T, TResult>>(body(left, right), left, right).Compile();
        }
        catch (InvalidOperationException ex)
        {
            string message = ex.Message;
            return delegate { throw new InvalidOperationException(message); };
        }
        catch (ArgumentException ex)
        {
            string message = ex.Message;
            return delegate { throw new InvalidOperationException(message); };
        }
    }
 
    private static Lazy<Func<T, T, TResult>> Create<TResult>(Func<Expression, Expression, BinaryExpression> body)
    {
        return new Lazy<Func<T, T, TResult>>(() => CreateCore<TResult>(body), true);
    }
 
    private static readonly Lazy<Func<T, T, T>> _add = Create<T>(Expression.Add);
 
    public static Func<T, T, T> Add
    {
        get { return _add.Value; }
    }
 
    ...
}

Sanmayce wrote:

I see no problem(s) at all, that's why I am asking.

Sanmayce wrote:

Are you sure, I am not

Sanmayce wrote:

something as general and important as hashing for lookups deserves special page

Sanmayce wrote:

Thank you, obviously my articles are not even articles, sorry, but blame me not - that's me, a C amateur trying to test/share interesting etudes.

Quote:

Among the materials prominent in the Snowden files are the agency’s shared “wikis,” databases to which intelligence analysts, operatives and others contributed their knowledge