小编col*_*ang的帖子

例如

BaseClass MyBase()
{
    public int Add(BaseClass next)
    {
        if (this is InheritedA && next is InheritedA)
            return 1;
        else if (this is InheritedA && next is InheritedB)
            return 2;
        else if (this is InheritedB && next is InheritedA)
            return 3;
        else if (this is InheritedB && next is InheritedB)
            return 4;      
     }
}

where InheritedA,InheritedB是它的继承类.实际上,还有更多的Inherited类,并Add根据其操作数的顺序和类型返回不同的结果.

我正在考虑使用多态和重载来重写它,但是,它变得相当复杂,我必须引入一个帮助方法来解析任一端的类型.

例如

InheritedA myA()
{
    public override int Add(BaseClass next)
    {
        return next.AddTo(this);
    }
}

现在我不得不把AddTo成BaseClass …

可能重复:
F#似乎比其他语言慢...我该怎么做才能加快速度？

我对模式匹配的性能有点好奇,所以我做了以下测试:

poolEven 包含10000个元素0,1,2,3,(2500相等)

testSize = 100000

IfelseEven(100000) 花费650毫秒(开关会更快,但我没有附加代码),而MatchEven(100000)需要7000毫秒,这是10倍的时间

性能下降是否来自Array.Fold？我100%肯定,如果我IEnumerable.Aggregate的速度会大大降低.但我认为F#处理Array.Fold比C#更好IEnumerable.Aggregate.我想比较两种语言中最常见(等效)编码方式的性能,而不是使它们相同的严格方法.

测试在x64版本中完成,平均10次试验进行适当的预热

C#:

public void IfelseEven(int testSize)
{
    Ifelse(testSize, poolEven);
}

void Ifelse(int testSize, int[] pool)
{
    long sum = 0;
    for (int i = 0; i < testSize; i++)
    {
        for (int j = 0; j < poolCapacity;j++ )
        {
            var item = pool[j];
            if (item == 0)
            {
                sum += 5;
            }
            else if (item == 1) …

Visual Studio不提供F#的自动格式化,是否有其他编辑器可用于自动化？

我想这将令合理的空格在算术运算符之间(a+b)进入(a + b)或赋值运算符=

我知道这在C#中是可行的,它可以生成简单有效的代码.---同一类的两个对象可以访问彼此的私有部分.

class c1
{
    private int A;

    public void test(c1 c)
    {
        c.A = 5;
    }
}

但在F#中似乎不可能,这是真的吗？

type c1()
     let A = 0
     member test (c: c1) = c.A

说,我有

member this.Test (x: 'a) = printfn "generic"
                           1
member this.Test (x: Object) = printfn "non generic"
                               2

如果我在C#中调用它

var a = test.Test(3);         // calls generic version
var b = test.Test((object)3); // calls non generic version
var c = test.Test<object>(3); // calls generic version

但是,在F#中

let d = test.Test(3);  // calls non generic version
let e = test.Test<int>(3); // calls generic version

所以我必须添加类型注释才能获得正确的重载方法.这是真的？如果是这样,那么为什么F#不能自动解析,因为已经推断出了参数类型？(无论如何,F#的重载决策顺序是什么？总是Object比它的继承类更受青睐？)

如果一个方法同时具有两个重载,其中一个将参数作为Object类型而另一个是泛型​​的并且两者都返回相同的类型,则有点危险.(就像在这个例子中,或者Assert.AreEqual在单元测试中),因为我们很可能在没有通知的情况下得到错误的重载(不会出现任何编译器错误).这不是问题吗？

更新:

有人可以解释一下

• 为什么F#解析Assert.AreEqual(3, 5)为Assert.AreEqual(Object a, Object b) …

这会奏效

  checkboxInput("test", "test", TRUE),
  conditionalPanel(
    condition="input.test",
    h2("test test")

  ),

但这不是

  checkboxInput("tes.t", "tes.t", TRUE),
  conditionalPanel(
    condition="input.tes.t",
    h2("tes.t tes.t")

  ),

文件中的哪个位置表示不支持带点的名称？有什么工作,所以我不必更改我的变量名称？

今天我发现我的程序中有一个错误,因为data.table自动删除NA了mean

例如:

> a<-data.table(a=c(NA,NA,FALSE,FALSE), b=c(1,1,2,2))
> a

> a[,list(mean(a), sum(a)),by=b]
   b V1 V2
1: 1  0 NA // Why V1 = 0 here? I had expected NA
2: 2  0  0


> mean(c(NA,NA,FALSE,FALSE))
[1] NA
> mean(c(NA,NA))
[1] NA
> mean(c(FALSE,FALSE))
[1] 0

这是预期的行为吗？

你可以看到一组有水平灰色边缘,另一组则没有.

如何在整个方面保持一致？

expand.grid(x=1:3, y=1:3)
a<-expand.grid(x=1:3, y=1:3)
a$value=rnorm(9)
a$group=1
b<-expand.grid(x=3, y=1:3)
b$value=rnorm(3)
b$group=2
c<-rbind(a,b)
ggplot(c, aes(x=factor(x), y=factor(y), fill=value)) + 
  geom_tile() + facet_grid(.~group, scale="free_x", space="free_x")

我对参数类型的内部构造函数中的类型注释感到有点困惑.

在JIT推理效率和运行时效率方面,以下4种方法有什么不同吗？

immutable MyType{T}
    x::T
    MyType{T}(x::T) = new{T}(x + x)
end

immutable MyType{T}
    x::T
    MyType(x::T) = new{T}(x + x)
end

immutable MyType{T}
    x::T
    MyType(x::T) = new(x + x)
end

immutable MyType{T}
    x::T
    MyType{T}(x::T) = new(x + x)
end

他们都为之努力 x = MyType{Int}(1)

假设x是一个Variable,我在教程中看到了使用op.name类似tf.scalar_summary(x.op.name, x)的东西.我想知道如果我可以代替x.op.name与x.name一般.

这两者有什么区别？它们可以互换吗？

with tf.name_scope('ab'):
    a = tf.Variable(tf.constant(1), name="v1")

a.name
u'ab_1/v1:0'

a.op.name
u'ab_1/v1'