Welcome to the Lounge

Quote:

I still try to code as if both of those things were still in play.

from datetime import datetime

def AddUp(x):
    if x > 0:
        return AddUp(x - 1) + x
    else:
        return 0

def CallAddUp():
    result = 0
    for x in range(1000000):
        result = result + AddUp(512)
    return result

started = datetime.now()
result = CallAddUp()
finished = datetime.now()
duration = finished - started

seconds = duration.seconds + duration.microseconds/1E6

print("CallAddUp() returned ", result, " in ", seconds, " seconds")

CallAddUp() returned  131328000000  in  77.055948  seconds

using System;
using System.Diagnostics;

namespace ScriptExample001a
{
    class Program
    {
        static long AddUp(long x)
        {
            if (x > 0)
            {
                return x + AddUp(x - 1);
            }
            else
            {
                return 0;
            }
        }

        static long CallAddUp()
        {
            long result = 0;
            for (long i = 0; i < 1000000; ++i)
            {
                result += AddUp(1000);
            }
            return result;
        }

        static void Main(string[] args)
        {
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            var resultValue = CallAddUp();
            stopwatch.Stop();
            var duration = stopwatch.Elapsed.TotalSeconds;

            Console.Out.WriteLine("C# CallAddUp( ) returned {0} in {1} seconds", resultValue, duration);
        }
    }
}

C# CallAddUp( ) returned 131328000000 in 1,2486408 seconds

uint64_t AddUp( uint64_t x )
{
    if ( x > 0 )
    {
        return AddUp( x - 1 ) + x;
    }
    else
    {
        return 0;
    }
}

uint64_t CallAddUp( )
{
    uint64_t result = 0;
    for ( size_t i = 0; i < 1000000; ++i )
    {
        result += AddUp( 512 );
    }
    return result;
}
int main()
{
    start = std::clock( );
    resultValue = CallAddUp( );
    duration = ( std::clock( ) - start ) / (double)CLOCKS_PER_SEC;
    printf( "C++ CallAddUp( ) returned %llu in %f seconds\n", resultValue, duration );
}

C++ CallAddUp( ) returned 131328000000 in 0.000000 seconds

Espen Harlinn wrote:

C++ CallAddUp( ) returned 131328000000 in 0.000000 seconds

M.D.V.

If something has a solution... Why do we have to worry about?. If it has no solution... For what reason do we have to worry about?
Help me to understand what I'm saying, and I'll explain it better to you
Rating helpful answers is nice, but saying thanks can be even nicer.

Quote:

No time at all?

Espen Harlinn wrote:

Nearly all of it gets computed at compile time

Quote:

Wasn't there a very similar issue with the first version of the classic Dhrystone benchmark?

Espen Harlinn wrote:

If the compiler can perform calculations up front, then that is a Good thing™; because, obviously, then the software doesn't have to do those calculations at runtime. C/C++, go, rust, and compilers for many other programming languages can do this pretty well.

Espen Harlinn wrote:

If the compiler can perform calculations up front, then that is a Good thing™

Quote:

Therefore anything under a millisecond would come up as 0

Quote:

All the decimal places give a false default sense of precision

Espen Harlinn wrote:

false default sense of precision

Quote:

they aren't mutually exclusive or contradictory.

#realJSOP wrote:

Has anyone seen this?