小编Pas*_*uoq的帖子

Eclipse编译器会自动将乘法乘以2的幂转换为位移,还是应该手动执行？谢谢您的帮助.

假设我有一个自定义集合类,它提供了一些内部线程同步.例如,简化的Add方法可能如下所示:

    public void Add(T item)
    {
        _lock.EnterWriteLock();
        try
        {
            _items.Add(item);
        }
        finally
        {
            _lock.ExitWriteLock();
        }
    }

最新的Code Contracts抱怨说CodeContracts: ensures unproven: this.Count >= Contract.OldValue(this.Count).问题是这真的无法证明.我可以确保在内部锁定内,Count将大于其先前的值.但是,在方法的退出处,我无法确保这一点.退出锁之后,在方法完成之前,另一个线程可以发出两个Removes(可能是不同的元素),使合同无效.

这里的基本问题是,只有在整个应用程序中一致地使用锁定以对集合进行所有访问时,才能认为集合合同在特定锁定上下文中是有效的.我的集合必须在多个线程中使用(非冲突的Add和Remove是一个有效的用例),但我仍然希望实现ICollection<T>.即使我知道我不能,我是否应该假装我能够满足这个确保要求的假设？令我印象深刻的是,BCL系列中没有一个能够真正确保这一点.

编辑:

基于一些进一步的调查,听起来最大的问题是合同重写者可能引入不正确的断言,导致运行时失败.基于此,我认为我唯一的选择是限制我的接口实现IEnumerable<T>,因为合同ICollection<T>暗示实现类不能提供内部线程同步(访问必须始终在外部同步.)这对我的特定情况是可接受的(所有客户端)希望改变集合直接了解类类型,但我很想知道是否有其他解决方案.

假设可以使用正确舍入的标准库函数,例如CRlibm中的函数.那么如何计算双精度输入的正确圆角立方根？

^{引用FAQ时,这个问题不是"[我]面临的实际问题".这有点像家庭作业.但立方根是经常发现的操作,可以想象这个问题是某人面临的实际问题.}

由于"最好的Stack Overflow问题中有一些源代码",这里有一些源代码:

  y = pow(x, 1. / 3.);

上面没有计算正确的圆形立方根,因为1/3不能完全表示为a double.

补充说明:

的文章介绍如何计算浮点立方根,但推荐牛顿迭代算法的最后一次迭代(S)将不得不做更高精度的算法来计算正确舍入的双精度立方根.这可能是计算它的最佳方式,但我仍在寻找一种利用现有正确舍入标准化功能的快捷方式.

C99包含一个cbrt()函数,但不能指望所有编译器都能正确舍入甚至忠实.CRlibm的设计者本可以选择包含cbrt()在提供的功能列表中,但他们没有.可以参考其他正确舍入的数学函数库中可用的实现.

作为一个学习项目,我使用c ++在软件中实现浮点运算(add,sub,mul,div).目标是更加熟悉浮点行为的底层细节.

我试图将我的处理器操作与精确位匹配,这意味着IEEE 754标准.到目前为止,它一直运行良好,添加,子和多种行为完美,我在大约1.1亿个随机操作上测试它,并获得与处理器硬件相同的结果.(虽然没有考虑边缘情况,溢出等).

在那之后,我开始转向最后一次操作,师.它工作正常并达到想要的结果,但有时,我得到最后一个尾数位错误,而不是四舍五入.我有点难以理解为什么.我一直在使用的主要参考是约翰·法里尔的精彩演讲(时间戳是在它显示如何圆形的时候):

https://youtu.be/k12BJGSc2Nc?t=1153

这种四舍五入对于所有的操作都非常有效,但是给了我这个部门的麻烦.让我举个具体的例子.我试图将645.68011474609375除以493.20962524414063

我得到的最终结果是:

我的:0-01111111-0100111100100011110000 0

c ++ _:0-01111111-0100111100100011110000 1

你可以看到除了最后一点之外的所有东西都匹配.我计算该部门的方式基于以下视频:https: //www.youtube.com/watch？v = fi8A4zz1d -s

在此之后,我计算了尾数精度24位(隐藏的一个+ 23尾数)的28位和保护的3位,圆形粘性以及可能的移位的额外一位.使用视频算法,我最多可以得到1的归一化移位,这就是为什么我在末尾有一个额外的位,以防在规范化中移入,因此将在舍入中可用.现在这是我从除法算法得到的结果:

 010100111100100011110000 0100
 ------------------------ ----
 ^                        grs^
 |__ to be normalized        |____ extra bit

如你所见,我在第24位获得0,所以我需要向左移动一个以获得正确的标准化.这意味着我会得到:

10100111100100011110000 100

根据John Farrier的视频,在100 grs位的情况下,如果尾数的LSB是1,我只会归一化.在我的情况下是零,这就是为什么我不对我的结果进行舍入.

我有点迷失的原因是我确信我的算法正在计算正确的尾数,我已经用在线计算器对其进行了双重检查,舍入策略适用于所有其他操作.此外,以这种方式计算会触发归一化,最终产生正确的指数.

我错过了什么吗？某个小细节？

令我感到奇怪的一件事是粘性位,在加法和乘法中你得到不同程度的移位,这导致粘性位触发的机会更高,在这种情况下,我只移动一个最大值粘性位不是很粘.

我希望我提供了足够的细节来解决我的问题.在这里你可以找到我的部门实现的底部,有点填充我用于调试的打印,但应该知道我在做什么,代码从第374行开始:

https://gist.github.com/giordi91/1388504fadcf94b3f6f42103dfd1f938

PS:同时我正在经历"科学家应该知道浮点数的一切",以便看看我是否错过了什么.

具有灵活数组成员的结构是一种可以声明变量并sizeof可以应用变量的类型，这一事实会导致以下程序中出现异常行为。

文件fam1.c：

#include <stdio.h>\n#include <stddef.h>\n\nstruct s {\n  char c;\n  char t[]; };\n\nextern struct s x;\n\nsize_t s_of_x(void);\n\nint main(void) {\n  printf("size of x: %zu\\n", sizeof x);\n  printf("size of x: %zu\\n", s_of_x());\n}\n

文件fam2.c：

#include <stddef.h>\n\nstruct s {\n  char c;\n  char t[2]; };\n\nstruct s x;\n\nsize_t s_of_x(void) {\n  return sizeof x;\n}\n

该程序在编译和运行时会发出一些令人惊讶的输出：

#include <stdio.h>\n#include <stddef.h>\n\nstruct s {\n  char c;\n  char t[]; };\n\nextern struct s x;\n\nsize_t s_of_x(void);\n\nint main(void) {\n  printf("size of x: %zu\\n", sizeof …

我想定义一个函数如下:

let f (a: int) (b: int) (c: int) (d: int): int =
  ...

是否可以缩短签名而不使其成为元组？因为我仍然希望f有4个参数.

非常感谢你.

编辑1:我认为重复int4次是没用的,并且想象出let f (a, b, c, d: int): int目前实际上不允许的东西.

我已经定义了一些类型:

type box = Box of int
type table = Table of int
type compare_result = Lt | Eq | Gt

似乎在OCaml中,我们不能定义具有相同名称但不同类型的参数的2个函数:

let compare (a: box) (b: box): compare_result = (...)
let compare (a: table) (b: table): compare_result = (...)

let res_box = compare (Box 1) (Box 2) in (* which is supposed to call the first funciton *) 
let res_table = compare (Table 1) (Table 2) in (* which is supposed to call the second function *)

那么有谁能告诉我OCaml的替代方案是什么？我们必须以不同的方式命名这两个函数吗？

典型的RSA实现包含多精度整数库.典型的多精度整数库使用动态分配将大整数表示为正确大小的机器字数组.

我希望在使用多精度整数时,只有加密或解密已知长度的消息(通常是对称加密密钥)时才会遇到数学整数的限制,例如RSA-2048,它会是可以通过静态地或在堆栈上为所有必要的中间结果分配空间来实现该算法.

我发现这个论坛帖子暗示这是可能的.它不表示最大整数大小.也许这很明显("你需要所有整数2048位,呃!").无论如何,如果有的话,我会对现有的实现更感兴趣.

作为一个不值得自己进入的副问题,椭圆曲线加密的典型实现是否需要动态分配？

在golang上是否有类似eval()的方法？

评估/执行JavaScript代码/表达式:

var x = 10;
var y = 20;
var a = eval("x * y") + "<br>";
var b = eval("2 + 2") + "<br>";
var c = eval("x + 17") + "<br>";

var res = a + b + c;

res的结果将是:

200
4
27

这可能在golang？为什么？

在OCaml中,如果我必须使用许多if-then-else编写函数,下面是我的愚蠢和丑陋的解决方案.

let foo () =
  let a1 = ... in
  if (a1) then
    result1
  else
    let a2 = ... in
    if (a2) then
      result2
    else
      let a3 = ... in
      if (a3) then
        result3
      else
        let a4 = ... in
        if (a4) then
          result4
        else
          result5.

如何美化上面的代码？我喜欢C/C++和Java风格,它使用"return"来保存下一个if语句的缩进.我可以用OCaml做同样的事情吗？

int foo () = {
  bool a1 = ...;
  if (a1)
    return result1;

  bool a2 = ...;
  if (a2)
    return result2;

  bool a3 = ...;
  if (a3)
    return result3;

  bool a4 = ...; …