Question

I’m working on a time-decay algorithm for a post system based on Reddit’s model here:
http://amix.dk/blog/post/19588

My working port is here:

public class Calculation
{
    protected DateTime Epoch = new DateTime(1970, 1, 1);

    protected long EpochSeconds(DateTime dt)
    {
        var ts = dt.Subtract(Convert.ToDateTime("1/1/1970 8:00:00 AM"));

        return ((((((ts.Days * 24) + ts.Hours) * 60) + ts.Minutes) * 60) + ts.Seconds);
    }

    protected int Score(int upVotes, int downVotes)
    {
        return upVotes - downVotes;
    }

    public double HotScore(int upVotes, int downVotes, DateTime date)
    {
        var s = Score(upVotes, downVotes);
        var order = Math.Log(Math.Max(Math.Abs(s), 1), 10);
        var sign = Math.Sign(s);
        var seconds = EpochSeconds(date) - 1134028003;
        return Math.Round(order + sign * ((double)seconds / 45000), 7);
    }
}

Based on the model output from the link provided, I should see gradual decay at 0-13 hours, and sharp decay after that.

What I’m seeing is very homogeneous decay, and scores much higher than the output from the original code (original code: 3480-3471).

Here is how I’m testing:

        Calculation c = new Calculation();
        double now = c.HotScore(100, 2, DateTime.Now);
        double fivehoursago = c.HotScore(100, 2, DateTime.Now.AddHours(-5));
        double tenhoursago = c.HotScore(100, 2, DateTime.Now.AddHours(-10));
        double elevenhoursago = c.HotScore(100, 2, DateTime.Now.AddHours(-11));
        double twelvehoursago = c.HotScore(100, 2, DateTime.Now.AddHours(-12));
        double thirteenhoursago = c.HotScore(100, 2, DateTime.Now.AddHours(-13));
        double fiftyhoursago = c.HotScore(100, 2, DateTime.Now.AddHours(-50));
        double onehundredhoursago = c.HotScore(100, 2, DateTime.Now.AddHours(-100));
        Console.WriteLine(now.ToString());
        Console.WriteLine(fivehoursago.ToString());
        Console.WriteLine(tenhoursago.ToString());
        Console.WriteLine(elevenhoursago.ToString());
        Console.WriteLine(twelvehoursago.ToString());
        Console.WriteLine(thirteenhoursago.ToString());
        Console.WriteLine(fiftyhoursago.ToString());
        Console.WriteLine(onehundredhoursago.ToString());
        Console.ReadLine();

Output values:

now:               4675.2993816
five hours:        4674.8993816
ten hours:         4674.4993816
eleven hours:      4674.4193816
twelve hours:      4674.3393816
thirteen hours:    4674.2593816
fifty hours:       4671.2993816
one-hundred hours: 4667.2993816

Clearly it’s SORT of working right, but something is off. It could be related to the lack of true *nix Epoch support, or the lack of analogous microseconds calculation, but something isn’t quite right.

Possible reference resources:
http://blogs.msdn.com/b/brada/archive/2004/03/20/93332.aspx
http://codeclimber.net.nz/archive/2007/07/10/convert-a-unix-timestamp-to-a-.net-datetime.aspx

Answer 1

Your primary problem is that the hot algorithm is time dependent. Your calculating the hot score at DateTime.Now, whereas the article was written on 23. Nov 2010 (look at the bottom of the article).

With some trial and error, it seems the data was calculated at approximately 2010-11-23 07:35. Try using that value rather than DateTime.Now, and you should get about the same results as the data in the graph shown.

Mind you, you could make the following improvements to your code:

public class Calculation
{
    private static readonly DateTime Epoch = new DateTime(1970, 1, 1);

    private double EpochSeconds(DateTime dt)
    {
        return (dt - Epoch).TotalSeconds;
    }

    private int Score(int upVotes, int downVotes)
    {
        return upVotes - downVotes;
    }

    public double HotScore(int upVotes, int downVotes, DateTime date)
    {
        int s = Score(upVotes, downVotes);
        double order = Math.Log(Math.Max(Math.Abs(s), 1), 10);
        int sign = Math.Sign(s);
        double seconds = EpochSeconds(date) - 1134028003;
        return Math.Round(order + sign * seconds / 45000, 7);
    }
}

My results:

3479.0956039
3478.6956039
3478.2956039
3478.2156039
3478.1356039
3478.0556039
3475.0956039
3471.0956039

Changes:

• Used the declared Epoch rather than a convert of 1970-01-01 08:00:00 (I think 08:00 is a mistake).
• You can subtract two dates using a - b; which is the same as a.Subtract(b) but more succinct and it mirrors the original Python code.
• A timespan does give you microsecond precision (Ticks are the smallest unit and equal 100 nanoseconds).
• Also, TotalSeconds gives you the total number of seconds within a time span; no need to recalculate that. The fractional part even gives you your microsecond precision.
• By returning double from EpochSeconds, you keep this precision.
• Made the data types explicit rather than var to clearly indicate what variable is what (they match the method signatures, so no implicit upcasting).
• Changed unneeded protected to private and made the Epoch a constant.