小编Voo*_*Voo的帖子

所以我正在阅读Peter Norvig的IAQ(不常见的问题 - 链接)并偶然发现:

您可能会惊讶地发现,在Sun JDK VM中,Object需要16个字节或4个字.这分解如下:有一个双字标题,其中一个字是指向对象类的指针,另一个字指向实例变量.即使Object没有实例变量,Java仍然为变量分配一个单词.最后,有一个"句柄",它是另一个指向双字头的指针.Sun表示,这种额外的间接性使垃圾收集变得更加简单.(已经有高性能的Lisp和Smalltalk垃圾收集器在至少15年内没有使用额外级别.我听说但尚未确认Microsoft JVM没有额外的间接级别.)

一个空的新的字符串()需要40个字节,或10个字:指针开销3个字,3个字的实例变量(开始索引,结束索引,和字符数组),和4个字为空字符数组.创建现有字符串的子字符串只需"6"字,因为char数组是共享的.将一个Integer键和整数值成一个Hashtable需要64个字节(除Hashtable的数组中被预先分配的四个字节):我会让你明白为什么.

好吧,我显然尝试过,但我无法弄明白.在下面我只统计单词:Hashtable put创建一个Hashtable $ Entry:3(开销)+4个变量(3个引用,我假设是1个字+ 1个int).我还假设他意味着该整数被新分配的(因此不被Integer类缓存或已经存在),其涉及到2*(3 [开销] + 1 [1 int值]).

所以最后我们最终得到了15个字或60个字节.所以我首先想到的是,作为一个内部类的Entry需要引用它的外部对象,但是它是静态的,所以这没有多大意义(确定我们必须存储一个指向父类的指针,但我会认为信息由VM存储在类头中.

只是空闲的好奇心,我很清楚这一切都取决于实际的JVM实现(在64位版本上的结果会有所不同),但我仍然不喜欢我无法回答的问题:)

编辑:只是为了让这个更清楚一点:虽然我清楚地知道,更紧凑的结构可以让我们一些性能优势,我同意,在一般担心的几个字节在这里或那里是浪费时间.我肯定不会因为这里的几个字节开销而停止使用Hashtable,就像我不会使用普通字符数组而不是字符串(或开始使用C).学习更多关于Java/JVM内部的内容纯粹是学术上的兴趣:)

静态解析重载运算符的原因是什么？这对我来说似乎是一个奇怪的选择 - 我能想到的唯一优势是以一些相当不直观的行为为代价的小的性能提升（但 JIT 有时也可以避免这种情况） - 即我基本上必须将操作员转发给一个虚函数来获得想要的行为。

这是刚刚从 C++ 接管还是有其他一些很好的理由？

所以我发现,如果你没有在c ++ 11中持有锁,那么发出一个条件变量是合法的.这似乎打开了一些令人讨厌的竞争条件的大门:

std::mutex m_mutex;
std::condition_variable m_cv;

T1: 
  std::unique_lock<std::mutex> lock(m_mutex);
  m_cv.wait(lock, []{ return !is_empty(); });

T2:
  generate_data();
  m_cv.notify();

是否保证T1永远不会在我们首先检查is_empty()(它返回true)的情况下结束,然后被T2抢占,这会创建一些数据并在我们实际等待它之前发出条件变量的信号？

如果这可以保证工作(我猜是这样,否则它看起来像是一个故意错误的API设计),这实际上是如何实现linux和stdlibc++？似乎我们需要另一个锁以避免这种情况.

在 JavaScript 中获取 [0, n) 范围内的随机整数的标准方法 - 或任何其他仅提供 random() 函数返回 [0,1) 范围内浮点数的语言 - 是使用Math.floor(Math.random() * n).

现在，假设我们正在对一组有理数进行运算，那么这背后的数学是微不足道的。问题是：由于 IEEE-754 浮点数的所有复杂性，结果分布实际上真的是均匀的吗？

考虑到一个浮点数和下一个更高的浮点数之间的差距随着它们变大而增加，我认为这应该会引入某种对较小数字的偏见。

为什么以下代码为通用案例提供编译错误？

abstract class Test<TItem> where TItem : IFoo
{
    public IEnumerable<IFoo> Foos { get; set; }

    public void Assign()
    {
        Foos = GetSomeSpecificList(); // works as expected
        Foos = GetSomeGenericList(); // compile error?
    }

    protected abstract ICollection<TItem> GetSomeGenericList();

    protected abstract ICollection<Foo> GetSomeSpecificList();
}

interface IFoo
{
}

class Foo : IFoo
{
}

我错过了什么或不是因为每个TItem都必须是IFoo,因此这个构造不可能违反类型安全吗？

我正在尝试使HTTP / 2与ASP.Net Core 2.2一起使用。我正在Windows 10 x64 1809上进行测试。

我将基本模板与以下Web主机构建器一起使用：

public static IWebHostBuilder CreateWebHostBuilderKestrel(string[] args)
{
    var builder = WebHost.CreateDefaultBuilder(args)
        .UseStartup<Startup>()
        .UseKestrel(options =>
        {
            options.Listen(IPAddress.Any, 35000,
                lo =>
                {
                    lo.Protocols = HttpProtocols.Http1AndHttp2;
                    lo.UseHttps(@"path to cert");
                });
        });
    return builder;
}

使用Chrome时，它将接受证书并通过HTTPS显示网站。问题是，在devtools部分中检查网络请求时，它使用的是HTTP / 1.1，而不是h2。

使用openssl s_client -connect 'host:35000' -cipher "EDH"给出以下输出：

New, TLSv1.2, Cipher is DHE-RSA-AES256-GCM-SHA384
Server public key is 2048 bit
Secure Renegotiation IS supported
Compression: NONE
Expansion: NONE
No ALPN negotiated
SSL-Session:
    Protocol  : TLSv1.2
    Cipher    : DHE-RSA-AES256-GCM-SHA384
    Session-ID: …

我基本上想要 string/FormattableString 的两个单独的重载（背景是我想推动人们使用字符串常量来记录日志消息并通过结构化日志而不是日志消息传递参数以简化分析。因此 FormattableString 日志记录方法将被废弃）。

现在由于编译器的工作方式，您不能直接重载方法，因为 FormattableString 在传递之前会转化为字符串。但有效的是有一个定义隐式重载的包装结构：

public struct StringIfNotFormattableStringAdapter
{
    public string StringValue { get; }

    private StringIfNotFormattableStringAdapter(string s)
    {
        StringValue = s;
    }

    public static implicit operator StringIfNotFormattableStringAdapter(string s)
    {
        return new StringIfNotFormattableStringAdapter(s);
    }

    public static implicit operator StringIfNotFormattableStringAdapter(FormattableString fs)
    {
        throw new InvalidOperationException("This only exists to allow correct overload resolution. " +
                                            "This should never be called since the FormattableString overload should be preferred to this.");
    }
}

public static class Test
{
    public static void …

在函数式语言(实际上我用过的所有函数式语言)中,语句和表达式之间没有区别,每个代码块的最后一个值是块的"返回值".另一方面,通常不被认为是纯粹功能的语言通常会引入这种区别.

作为我正在谈论的一个例子,以下python代码打印None:

def foo():
    5 + 5
print(foo())

而方案代码打印 10

(define (foo) (+ 5 5))
(display (foo))

显然,我对那些喜欢一种风格的人的主观答案不感兴趣,而是客观原因.

对我而言,这种区别似乎使得语言的语法和实现更加复杂(一个不那么明显的例子就是模板和void类型的c ++标准中的必要例外,或者引入了"快捷方式if语句",比如?c - 受影响的语言)没有真正的好处 - 但很可能有一个原因,即使是新的现代语言仍然有这种区别.

我有一个numpy数组形式的大图像(opencv将其作为3个uint8值的2d数组返回)并且想要为每个像素计算高斯内核的总和,即(在那里仍然没有LaTeX支持？):

对于具有指定权重w,平均和对角协方差矩阵的N个不同内核.

所以基本上我想要一个功能compute_densities(image, kernels) -> numpy array of floats.在python中有效执行此操作的最佳方法是什么？如果scipy中还没有库函数,我会感到惊讶,但是很久以前我在uni上有统计数据,所以我对文档的细节感到有些困惑.

基本上我想要以下,比天真的python更有效(2pi ^ { - 3/2}被忽略,因为它是一个对我来说无关紧要的常数因素,因为我只对概率之间的比率感兴趣)

def compute_probabilities(img, kernels):
    np.seterr(divide='ignore') # 1 / covariance logs an error otherwise
    result = np.zeros((img.shape[0], img.shape[1]))
    for row_pos, row_val in enumerate(img):
        for col_pos, val in enumerate(row_val):
            prob = 0.0
            for kernel in kernels:
                mean, covariance, weight = kernel
                val_sub_mu = np.array([val]).T - mean
                cov_inv = np.where(covariance != 0, 1 / covariance, 0)
                tmp = val_sub_mu.T.dot(cov_inv).dot(val_sub_mu)
                prob += weight / np.sqrt(np.linalg.norm(covariance)) * \
                        math.exp(-0.5 * …

我正在阅读John Regehr的博客,了解他如何给学生们一个关于饱和算术的任务.有趣的是,代码必须按原样编译,同时使用typedef指定不同的整数类型,请参阅以下完整标题的摘录:

typedef signed int mysint;
//typedef signed long int mysint;

mysint sat_signed_add (mysint, mysint);

mysint sat_signed_sub (mysint, mysint);

相应的无符号版本很容易实现(虽然我实际上不确定填充位是否也不会产生问题),但我实际上看不出如何获得未知签名的最大值(或最小值)在C型,而无需使用宏MAX_UND MIN_或导致未定义的行为.

我在这里遗漏了什么,或者作业是否有缺陷(或者更可能是我错过了他给学生们的一些重要信息)？