小编col*_*ang的帖子

use std::collections::HashMap;
use std::collections::hash_map::Entry::*;

struct A {
    map: HashMap<String, String>,
    i: i32
}
impl A {
    fn test(&mut self) {
        match self.map.get("abc") {
            None => {},
            Some(x) => self.trigger(&x)
        }
    }

    fn trigger(&mut self, x: &str) {
        self.i += 1;
    }
}

该代码不起作用，因为可变self.trigger借用self，同时在范围内self.map.get保持不可变借用self。

鉴于我可以确保不trigger修改，有什么方法可以使其工作吗self.map？

我不能一成不变地trigger借用self，就像 我可以为 self.callbacks: Vec<Box<FnMut>>? 一样借用 self 吗？

我正在使用 rustc 1.19.0-nightly。

火花v2.4

spark.sql.debug.maxToStringFields在这里定义https://github.com/apache/spark/blob/master/sql/catalyst/src/main/scala/org/apache/spark/sql/internal/SQLConf.scala

不知怎的，它变成spark.debug.maxToStringFields了https://github.com/apache/spark/blob/master/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/util/package.scala#L178

事实上，工作spark.sql.debug.maxToStringFields时不工作spark.debug.maxToStringFields

spark = SparkSession \
    .builder \
    .master('local[15]') \
    .appName('Notebook') \
    .config('spark.sql.debug.maxToStringFields', 2000) \
    .config('spark.debug.maxToStringFields', 2000) \
    .getOrCreate()

df = spark.createDataFrame(spark.range(1000).rdd.map(lambda x: range(100)))
df.repartition(1).write.mode('overwrite').parquet('test.parquet')

df = spark.read.parquet('test.parquet')
df.select('*').explain()


 FileScan parquet [_1#0L,_2#1L,_3#2L,_4#3L,_5#4L,_6#5L,_7#6L,_8#7L,_9#8L,_10#9L,_11#10L,_12#11L,_13#12L,_14#13L,_15#14L,_16#15L,_17#16L,_18#17L,_19#18L,_20#19L,_21#20L,_22#21L,_23#22L,_24#23L,_25#24L,_26#25L,_27#26L,_28#27L,_29#28L,_30#29L,_31#30L,_32#31L,_33#32L,_34#33L,_35#34L,_36#35L,_37#36L,_38#37L,_39#38L,_40#39L,_41#40L,_42#41L,_43#42L,_44#43L,_45#44L,_46#45L,_47#46L,_48#47L,_49#48L,_50#49L,_51#50L,_52#51L,_53#52L,_54#53L,_55#54L,_56#55L,_57#56L,_58#57L,_59#58L,_60#59L,_61#60L,_62#61L,_63#62L,_64#63L,_65#64L,_66#65L,_67#66L,_68#67L,_69#68L,_70#69L,_71#70L,_72#71L,_73#72L,_74#73L,_75#74L,_76#75L,_77#76L,_78#77L,_79#78L,_80#79L,_81#80L,_82#81L,_83#82L,_84#83L,_85#84L,_86#85L,_87#86L,_88#87L,_89#88L,_90#89L,_91#90L,_92#91L,_93#92L,_94#93L,_95#94L,_96#95L,_97#96L,_98#97L,_99#98L,_100#99L]

如果.config('spark.debug.maxToStringFields', 2000) \被注释掉那么它就会显示... 76 more fields

有什么用spark.sql.debug.maxToStringFields？

Dictionary<TKey, TValue>.KeyCollection Class实现了contains通过扩展方法IEnumerable,即O(n)

为什么它不具有O(1)的原生的？它的HashSet不是吗？

比方说,如果我想集中测试一些继承类的类型,并且需要良好的性能,我应该使用enum存储所有可能的类型,并使用枚举相等来测试类型而不是使用is.

例如

switch (myObject.Type)
      {
      case myType.type1:
                 myObject as myInheritedObject1;
                 ...
                 break;
      case myType.type2:
                 myObject as myInheritedObject2;
                 ...
                 break;
      case myType.type3:
                 myObject as myInheritedObject3;
                 ...
                 break;
         ...
     }

要么

    var tmp = myObject as myInheritedObject1;
    if (tmp != null)
      {
      }
    else 
      {
        tmp = myObject as myInheritedObject2;
        if (tmp != null)
        {
        }
          else 
            {
             tmp = myObject as myInheritedObject3;
             if (tmp != null)
             {
             }
      }   }}

 for i in a..b do
     res <- res * myarray.[i]
 res

我必须使用喜欢

  Array.fold (*) 1 (Array.sub myarray a (b - a + 1))

,我认为这是相当慢,而不是那么简洁？

chance<-c(0.11,0.12,0.13,0.14,0.15)
aaa<-function(x,y) {
  assignChance <- function (a,b,v) {
    if (a == 0)
      if (b == 0) 1-v
      else v
    else
      if (b == 0) 0
      else 1
  }
  sapply(x,assignChance,y,chance) # this is wrong
}
aaa(c(1,1,0,0,1),c(1,1,1,0,0))

我期望结果为:1,1,0.13,0.86,0

有没有更好的方法来实现这个功能.我觉得我现在学尝试是在功能性语言,我可以只使用相当难看Array.map3plue pattern match.

有没有的向量版本switch只是喜欢ifelse？

值类型可以存储在线程的堆栈中,IL在执行堆栈中运行(抽象概念).

int y=0;
int a=0;
int b=0;

int x = y + (a - b);

IL_0001:  ldc.i4.0    
IL_0002:  stloc.0     // y
IL_0003:  ldc.i4.0    
IL_0004:  stloc.1     // a
IL_0005:  ldc.i4.0    
IL_0006:  stloc.2     // b
IL_0007:  ldloc.0     // y
IL_0008:  ldloc.1     // a
IL_0009:  ldloc.2     // b
IL_000A:  sub         
IL_000B:  add         
IL_000C:  stloc.3     // x

现在stloc.0弹出执行堆栈中的值并存储到本地变量列表中.因此,局部变量列表必须存储在执行堆栈以外的其他空间中.什么是局部变量列表？它是一个线程的堆栈吗？

另外,哪个堆栈.maxstack = 3参考方法？它是局部变量列表的大小吗？或者将额外存储的最大大小推入执行堆栈？

在我看来,执行堆栈是正确的堆栈,因为它只支持push和pop.局部变量列表支持load索引和store索引.这与堆栈有什么关系？

更新:

ECMA 335 I.12.3机器状态明确回答了我的问题.

为什么head和tail工作方式不同data.table？它是按设计的吗？

> head(data.frame(x=1:10), -2)
  x
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
> head(data.table(x=1:10), -2)
Error in seq_len(min(n, nrow(x))) : 
  argument must be coercible to non-negative integer
> tail(data.table(x=1:10), -2)
    x
1: NA
2: NA
3: NA
4: 10
> tail(data.frame(x=1:10), -2)
    x
3   3
4   4
5   5
6   6
7   7
8   8
9   9
10 10

我正在尝试使用R中的COMPoissonReg进行Conway-Maxwell-Poisson回归

但是,对于大型数据集来说,它非常慢.因此,我试图剖析并检查源代码.

大部分时间(> 95%)花在一个函数上COMPoissonReg:::computez,相当于:

test <- function (lambda, nu, max=100) 
{
    forans <- matrix(0, ncol = max + 1, nrow = length(lambda))
    for (j in 1:max) {
        temp <- matrix(0, ncol = j, nrow = length(lambda))
        for (i in 1:j) {
            temp[, i] <- lambda/(i^nu)
        }
        for (k in 1:length(lambda)) {
            forans[k, j + 1] <- prod(temp[k, ])
        }
    }
    forans[, 1] <- rep(1, length(lambda))
    ans <- rowSums(forans)
    return(ans)
}

v这里是nu,lambda是向量,max是上限s(这里它设置为100作为近似无穷大).

并不真正需要的特殊背景的问题统计知识,但链接 …

我的用例是在小于 10 的所有点上评估泊松 pmf，我会用不同的 lambda 多次调用这样的函数。lambdas 事先未知，所以我无法矢量化 lambdas。

我从某个地方听说过一个秘密技巧，那就是使用_pmf. 这样做的缺点是什么？但是，它仍然有点慢，有没有办法在不从头开始重写 C 中的 pmf 的情况下改进它？

%timeit scipy.stats.poisson.pmf(np.arange(0,10),3.3)
%timeit scipy.stats.poisson._pmf(np.arange(0,10),3.3)
a = np.arange(0,10)
%timeit scipy.stats.poisson._pmf(a,3.3)

10000 loops, best of 3: 94.5 µs per loop
100000 loops, best of 3: 15.2 µs per loop
100000 loops, best of 3: 13.7 µs per loop

更新

好吧，我只是懒得用 cython 写。我原以为所有离散分布都有一个更快的解决方案，可以对连续的x. 例如P(X=3) = P(X=2) * lambda / 3 if X ~ Pois(lambda)

相关：`scipy.stat.distributions` 的内置概率密度函数是否比用户提供的慢？

我现在对 Scipy 和 Python 不太信任了。库功能没有我预想的那么先进。