Question

我有这个锡兰代码：

Integer fact(Integer n)
{
    return (n<=1)then 1 else n*fact(n-1);
}
Integer? factorial(Integer|String|Null n)
{
    Integer? num;
    if(is String n)
    {
        num=parseInteger(n);
    }
    else if(is Integer n)
    {
        num=n;      
    }   
    else
    {
        num=null;
    }
    if(exists num)
    {
        if(num<0)
        {
            return null;
        }
        if(num==0)
        {
            return 1;
        }
        return (2..num).fold(1)((x,y)=>x*y);//line 1
    }
    else
    {
        return null;        
    }       
}
shared void main() 
{
    print("enter a number");
    value input=process.readLine()?.trimmed;
    value starttime=system.milliseconds;
    value fact=factorial(input);
    value elapsedtime=(system.milliseconds-starttime).float/1000;
    if(exists fact)
    {
        print("(!n)=``fact``");
        print(elapsedtime);
    }
    else
    {
        print("Error, either you gave a negative number or you didn't enter an integer(or did you left the input blank ?)");
    }   
}

在第1行我用折叠来计算阶乘，我的性能在0.08到0.06秒之间。

现在，如果我用这个替换第1行：

return fact(num);

我的性能介于0.021和0.012之间，为什么会这样？

在这种情况下我尝试的数字是10。

Answer 1

首先发表几点评论：

不要使用>>> check_numeric(1) >>> check_numeric(1.5) >>> check_numeric(10L) >>> check_numeric(complex(1, 2)) >>> check_numeric('spam') ValueError: spam is not numeric进行小型测量，这是出了名的不精确（它的最大分辨率是1/60秒或大约16毫秒），使用{ {1}}而不是
对于Java VM而言，这是一个太小的基准，无法说出任何有价值的东西，虚拟机需要热身＆＃34;在进行任何优化之前。有关详细信息，请参阅How do I write a correct micro-benchmark in Java?

但除此之外system.milliseconds可能更快的一个原因是因为它的代码在内部被优化以使用Java原始类型，而system.nanoTime是一个通用函数，这可能意味着很多拳击正在进行的地方。

现在，在处理基本类型（如fact()和fold()等）时，Ceylon在优化具有泛型参数或返回类型的函数方面还不是很好。希望在未来的版本中，我们能够有所补救。

为什么递归因子比锡兰中的折叠更快

1 个答案: