45

是否有 OCaml 库可以利用 IA-32 和 x86-64 架构上的 80 位扩展精度浮点类型？

我知道MPFR 绑定，但我理想的库会更轻量级。利用历史浮点指令将是理想的。

4

1 回答 1

3

由于语言对ffi的支持，这样一个库的实现可以在编译器之外实现。

该库必须分为两部分：本机 ocaml 源代码部分和 C 运行时部分。OCaml 源必须包含数据类型声明，以及所有导入函数的声明。例如，添加操作将是：

(** basic binary operations on long doubles *)
external add : t -> t -> t = "ml_float80_add"
external sub : t -> t -> t = "ml_float80_sub"
external mul : t -> t -> t = "ml_float80_mul"
external div : t -> t -> t = "ml_float80_div"

在 C 代码中，ml_float80_add应该定义函数，如 OCaml 手册中所述：

CAMLprim value ml_float80_add(value l, value r){
   float80 rlf = Float80_val(l);
   float80 rrf = Float80_val(r);
   float80 llf = rlf + rrf;
   value res = ml_float80_copy(llf);
   return res;
}

在这里，我们将 OCamlvalue运行时表示转换为原生 C 值，对它们使用二元运算符，并返回一个新的 OCaml 值。该ml_float80_copy函数执行该运行时表示的分配。

sub同样， ,mul和函数的 C 实现也div应该在那里定义。可以注意到这些函数在签名和实现上的相似之处，并通过使用 C 宏进行抽象：

#define FLOAT80_BIN_OP(OPNAME,OP)                   \
  CAMLprim value ml_float80_##OPNAME(value l, value r){     \
    float80 rlf = Float80_val(l);                           \
    float80 rrf = Float80_val(r);                           \
    float80 llf = rlf OP rrf;                               \
    value res = ml_float80_copy(llf);           \
    return res;                     \
  }


FLOAT80_BIN_OP(add,+);
FLOAT80_BIN_OP(sub,-);
FLOAT80_BIN_OP(mul,*);
FLOAT80_BIN_OP(div,/);

OCaml 和 C 模块的其余部分应遵循。

关于如何将float80C 类型编码为 OCaml 值有很多可能性。最简单的选择是使用一个字符串，并将 raw 存储在其中long double。

type t = string

在 C 端，我们定义了将 OCaml 值来回转换为 C 值的函数：

#include <caml/mlvalues.h>
#include <caml/alloc.h>
#include <caml/misc.h>
#include <caml/memory.h>


#define FLOAT80_SIZE 10  /* 10 bytes */

typedef long double float80;

#define Float80_val(x) *((float80 *)String_val(x))

void float80_copy_str(char *r, const char *l){
   int i;
   for (i=0;i<FLOAT80_SIZE;i++)
      r[i] = l[i];
}

void store_float80_val(value v,float80 f){
   float80_copy_str(String_val(v), (const char *)&f);
}

CAMLprim value ml_float80_copy(value r, value l){
   float80_copy_str(String_val(r),String_val(l));
   return Val_unit;
}

但是，该实现不支持 OCaml 内置的多态比较函数Pervasive.compare以及其他一些功能。在上面的 float80 类型上使用该函数会误导比较函数认为这些值是字符串，并对其内容进行字典比较。

不过，支持这些特殊功能很简单。我们将 OCaml 类型重新定义为抽象类型，并更改 C 代码以创建和处理我们的 float80 的自定义结构：

#include <caml/mlvalues.h>
#include <caml/alloc.h>
#include <caml/misc.h>
#include <caml/memory.h>
#include <caml/custom.h>
#include <caml/intext.h>

typedef struct {
   struct custom_operations *ops;
   float80 v;  
} float80_s;

#define Float80_val(x) *((float80 *)Data_custom_val(x))

inline int comp(const float80 l, const float80 r){
   return l == r ? 0: (l < r ? -1: 1); 
}

static int float80_compare(value l, value r){
   const float80 rlf = Float80_val(l);
   const float80 rrf = Float80_val(r);
   const int llf = comp(rlf,rrf);
   return llf;
}

/* other features implementation here */

CAMLexport struct custom_operations float80_ops = {
  "float80", custom_finalize_default, float80_compare, float80_hash,
  float80_serialize, float80_deserialize, custom_compare_ext_default
};

CAMLprim value ml_float80_copy(long double ld){
  value res = caml_alloc_custom(&float80_ops, FLOAT80_SIZE, 0, 1);  
  Float80_val(res) = ld;
  return res;
}

然后我们建议使用 ocamlbuild 和一个小的 bash 脚本来构建整个东西。

于 2013-03-18T16:00:44.893 回答