BranchesTags

Repository files navigation

The Zarith library

OVERVIEW

This library implements arithmetic and logical operations over arbitrary-precision integers.

The module is simply named Z. Its interface is similar to that of the Int32, Int64 and Nativeint modules from the OCaml standard library, with some additional functions. See the file z.mlip for documentation.

The implementation uses GMP (the GNU Multiple Precision arithmetic library) to compute over big integers. However, small integers are represented as unboxed Caml integers, to save space and improve performance. Big integers are allocated in the Caml heap, bypassing GMP's memory management and achieving better GC behavior than e.g. the MLGMP library. Computations on small integers use a special, faster path (coded in assembly for some platforms and functions) eschewing calls to GMP, while computations on large intergers use the low-level MPN functions from GMP.

Arbitrary-precision integers can be compared correctly using OCaml's polymorphic comparison operators (=, <, >, etc.). This requires OCaml version 3.12.1 or later, though.

Additional features include:

  • a module Q for rationals, built on top of Z (see q.mli)
  • a compatibility layer Big_int_Z that implements the same API as Big_int from the legacy Num library, but uses Z internally

REQUIREMENTS

  • OCaml, preferably version 3.12.1 or later. (Earlier versions are usable but generic comparisons will misbehave.)
  • Either the GMP library or the MPIR library, including development files.
  • GCC or Clang or a gcc-compatible C compiler and assembler (other compilers may work).
  • The Perl programming language.
  • The Findlib package manager (optional, recommended).

INSTALLATION

  1. First, run the "configure" script by typing:
 ./configure

The configure script has a few options. Use the -help option to get a list and short description of each option.

  1. It creates a Makefile, which can be invoked by:
 make

This builds native and bytecode versions of the library.

  1. The libraries are installed by typing:
 make install

or, if you install to a system location but are not an administrator

 sudo make install

If Findlib is detected, it is used to install files. Otherwise, the files are copied to a zarith/ subdirectory of the directory given by ocamlc -where.

The libraries are named zarith.cmxa and zarith.cma, and the Findlib module is named zarith.

Compiling and linking with the library requires passing the -I +zarith option to ocamlc / ocamlopt, or the -package zarith option to ocamlfind.

  1. (optional, recommended) Test programs are built and run by the additional command
 make tests

(but these are not installed).

  1. (optional) HTML API documentation is built (using ocamldoc) by the additional command
 make doc

LICENSE

This Library is distributed under the terms of the GNU Library General Public License version 2, with a special exception allowing unconstrained static linking. See LICENSE file for details.

AUTHORS

  • Antoine Miné, Université Pierre et Marie Curie, formerly ENS Paris.
  • Xavier Leroy, INRIA Paris-Rocquencourt.
  • Pascal Cuoq, CEA LIST.
  • Christophe Troestler (toplevel module)

COPYRIGHT

Copyright (c) 2010-2011 Antoine Miné, Abstraction project. Abstraction is part of the LIENS (Laboratoire d'Informatique de l'ENS), a joint laboratory by: CNRS (Centre national de la recherche scientifique, France), ENS (École normale supérieure, Paris, France), INRIA Rocquencourt (Institut national de recherche en informatique, France).

CONTENTS

Source filesDescription
configureconfiguration script
caml_z.cC implementation of all functions
caml_z_*.Sasm implementation for a few functions
z_pp.plscript to generate z.ml[i] from z.ml[i]p
z.ml[i]ptemplates used to generate z.ml[i]p
big_int_z.ml[i]wrapper to provide a Big_int compatible API to Z
q.ml[i]rational library, pure OCaml on top of Z
zarith_top.mltoplevel module to provide pretty-printing
projet.makbuilds Z, Q and the tests
tests/simple regression tests and benchmarks

Note: z_pp.pl simply scans the asm file (if any) to see which functions have an asm implementation. It then fixes the external statements in .mlp and .mlip accordingly. The argument to z_pp.pl is the suffix * of the caml_z_*.S to use (guessed by configure).

About

The Zarith library implements arithmetic and logical operations over arbitrary-precision integers and rational numbers. The implementation, based on GMP, is very efficient.

Resources

Readme
License
Activity
Custom properties

Stars

0 stars

Watchers

1 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
The Zarith library
OVERVIEW
This library implements arithmetic and logical operations over
arbitrary-precision integers.
The module is simply named Z. Its interface is similar to that of
the Int32, Int64 and Nativeint modules from the OCaml standard
library, with some additional functions. See the file z.mlip for
documentation.
The implementation uses GMP (the GNU Multiple Precision arithmetic
library) to compute over big integers.
However, small integers are represented as unboxed Caml integers, to save
space and improve performance. Big integers are allocated in the Caml heap,
bypassing GMP's memory management and achieving better GC behavior than e.g.
the MLGMP library.
Computations on small integers use a special, faster path (coded in assembly
for some platforms and functions) eschewing calls to GMP, while computations
on large intergers use the low-level MPN functions from GMP.
Arbitrary-precision integers can be compared correctly using OCaml's
polymorphic comparison operators (=, <, >, etc.).
This requires OCaml version 3.12.1 or later, though.
Additional features include:
  • a module Q for rationals, built on top of Z (see q.mli)
  • a compatibility layer Big_int_Z that implements the same API as Big_int from the legacy Num library, but uses Z internally
REQUIREMENTS
  • OCaml, preferably version 3.12.1 or later. (Earlier versions are usable but generic comparisons will misbehave.)
  • Either the GMP library or the MPIR library, including development files.
  • GCC or Clang or a gcc-compatible C compiler and assembler (other compilers may work).
  • The Perl programming language.
  • The Findlib package manager (optional, recommended).
INSTALLATION
  1. First, run the "configure" script by typing:
 ./configure

The configure script has a few options. Use the -help option to get a
list and short description of each option.
  1. It creates a Makefile, which can be invoked by:
 make

This builds native and bytecode versions of the library.
  1. The libraries are installed by typing:
 make install

or, if you install to a system location but are not an administrator
 sudo make install

If Findlib is detected, it is used to install files.
Otherwise, the files are copied to a zarith/ subdirectory of the directory
given by ocamlc -where.
The libraries are named zarith.cmxa and zarith.cma, and the Findlib module
is named zarith.
Compiling and linking with the library requires passing the -I +zarith
option to ocamlc / ocamlopt, or the -package zarith option to ocamlfind.
  1. (optional, recommended) Test programs are built and run by the additional command
 make tests

(but these are not installed).
  1. (optional) HTML API documentation is built (using ocamldoc) by the additional command
 make doc

LICENSE
This Library is distributed under the terms of the GNU Library General
Public License version 2, with a special exception allowing unconstrained
static linking.
See LICENSE file for details.
AUTHORS
  • Antoine Miné, Université Pierre et Marie Curie, formerly ENS Paris.
  • Xavier Leroy, INRIA Paris-Rocquencourt.
  • Pascal Cuoq, CEA LIST.
  • Christophe Troestler (toplevel module)
COPYRIGHT
Copyright (c) 2010-2011 Antoine Miné, Abstraction project.
Abstraction is part of the LIENS (Laboratoire d'Informatique de l'ENS),
a joint laboratory by:
CNRS (Centre national de la recherche scientifique, France),
ENS (École normale supérieure, Paris, France),
INRIA Rocquencourt (Institut national de recherche en informatique, France).
CONTENTS
Source filesDescription
configureconfiguration script
caml_z.cC implementation of all functions
caml_z_*.Sasm implementation for a few functions
z_pp.plscript to generate z.ml[i] from z.ml[i]p
z.ml[i]ptemplates used to generate z.ml[i]p
big_int_z.ml[i]wrapper to provide a Big_int compatible API to Z
q.ml[i]rational library, pure OCaml on top of Z
zarith_top.mltoplevel module to provide pretty-printing
projet.makbuilds Z, Q and the tests
tests/simple regression tests and benchmarks
Note: z_pp.pl simply scans the asm file (if any) to see which functions have
an asm implementation. It then fixes the external statements in .mlp and
.mlip accordingly.
The argument to z_pp.pl is the suffix * of the caml_z_*.S to use (guessed by configure).
About
The Zarith library implements arithmetic and logical operations over arbitrary-precision integers and rational numbers. The implementation, based on GMP, is very efficient.
Resources
Readme
License
Activity
Custom properties
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix");
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
The Zarith library
OVERVIEW
This library implements arithmetic and logical operations over
arbitrary-precision integers.
The module is simply named Z. Its interface is similar to that of
the Int32, Int64 and Nativeint modules from the OCaml standard
library, with some additional functions. See the file z.mlip for
documentation.
The implementation uses GMP (the GNU Multiple Precision arithmetic
library) to compute over big integers.
However, small integers are represented as unboxed Caml integers, to save
space and improve performance. Big integers are allocated in the Caml heap,
bypassing GMP's memory management and achieving better GC behavior than e.g.
the MLGMP library.
Computations on small integers use a special, faster path (coded in assembly
for some platforms and functions) eschewing calls to GMP, while computations
on large intergers use the low-level MPN functions from GMP.
Arbitrary-precision integers can be compared correctly using OCaml's
polymorphic comparison operators (=, <, >, etc.).
This requires OCaml version 3.12.1 or later, though.
Additional features include:
  • a module Q for rationals, built on top of Z (see q.mli)
  • a compatibility layer Big_int_Z that implements the same API as Big_int from the legacy Num library, but uses Z internally
REQUIREMENTS
  • OCaml, preferably version 3.12.1 or later. (Earlier versions are usable but generic comparisons will misbehave.)
  • Either the GMP library or the MPIR library, including development files.
  • GCC or Clang or a gcc-compatible C compiler and assembler (other compilers may work).
  • The Perl programming language.
  • The Findlib package manager (optional, recommended).
INSTALLATION
  1. First, run the "configure" script by typing:
 ./configure

The configure script has a few options. Use the -help option to get a
list and short description of each option.
  1. It creates a Makefile, which can be invoked by:
 make

This builds native and bytecode versions of the library.
  1. The libraries are installed by typing:
 make install

or, if you install to a system location but are not an administrator
 sudo make install

If Findlib is detected, it is used to install files.
Otherwise, the files are copied to a zarith/ subdirectory of the directory
given by ocamlc -where.
The libraries are named zarith.cmxa and zarith.cma, and the Findlib module
is named zarith.
Compiling and linking with the library requires passing the -I +zarith
option to ocamlc / ocamlopt, or the -package zarith option to ocamlfind.
  1. (optional, recommended) Test programs are built and run by the additional command
 make tests

(but these are not installed).
  1. (optional) HTML API documentation is built (using ocamldoc) by the additional command
 make doc

LICENSE
This Library is distributed under the terms of the GNU Library General
Public License version 2, with a special exception allowing unconstrained
static linking.
See LICENSE file for details.
AUTHORS
  • Antoine Miné, Université Pierre et Marie Curie, formerly ENS Paris.
  • Xavier Leroy, INRIA Paris-Rocquencourt.
  • Pascal Cuoq, CEA LIST.
  • Christophe Troestler (toplevel module)
COPYRIGHT
Copyright (c) 2010-2011 Antoine Miné, Abstraction project.
Abstraction is part of the LIENS (Laboratoire d'Informatique de l'ENS),
a joint laboratory by:
CNRS (Centre national de la recherche scientifique, France),
ENS (École normale supérieure, Paris, France),
INRIA Rocquencourt (Institut national de recherche en informatique, France).
CONTENTS
Source filesDescription
configureconfiguration script
caml_z.cC implementation of all functions
caml_z_*.Sasm implementation for a few functions
z_pp.plscript to generate z.ml[i] from z.ml[i]p
z.ml[i]ptemplates used to generate z.ml[i]p
big_int_z.ml[i]wrapper to provide a Big_int compatible API to Z
q.ml[i]rational library, pure OCaml on top of Z
zarith_top.mltoplevel module to provide pretty-printing
projet.makbuilds Z, Q and the tests
tests/simple regression tests and benchmarks
Note: z_pp.pl simply scans the asm file (if any) to see which functions have
an asm implementation. It then fixes the external statements in .mlp and
.mlip accordingly.
The argument to z_pp.pl is the suffix * of the caml_z_*.S to use (guessed by configure).
About
The Zarith library implements arithmetic and logical operations over arbitrary-precision integers and rational numbers. The implementation, based on GMP, is very efficient.
Resources
Readme
License
Activity
Custom properties
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms");
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
The Zarith library
OVERVIEW
This library implements arithmetic and logical operations over
arbitrary-precision integers.
The module is simply named Z. Its interface is similar to that of
the Int32, Int64 and Nativeint modules from the OCaml standard
library, with some additional functions. See the file z.mlip for
documentation.
The implementation uses GMP (the GNU Multiple Precision arithmetic
library) to compute over big integers.
However, small integers are represented as unboxed Caml integers, to save
space and improve performance. Big integers are allocated in the Caml heap,
bypassing GMP's memory management and achieving better GC behavior than e.g.
the MLGMP library.
Computations on small integers use a special, faster path (coded in assembly
for some platforms and functions) eschewing calls to GMP, while computations
on large intergers use the low-level MPN functions from GMP.
Arbitrary-precision integers can be compared correctly using OCaml's
polymorphic comparison operators (=, <, >, etc.).
This requires OCaml version 3.12.1 or later, though.
Additional features include:
  • a module Q for rationals, built on top of Z (see q.mli)
  • a compatibility layer Big_int_Z that implements the same API as Big_int from the legacy Num library, but uses Z internally
REQUIREMENTS
  • OCaml, preferably version 3.12.1 or later. (Earlier versions are usable but generic comparisons will misbehave.)
  • Either the GMP library or the MPIR library, including development files.
  • GCC or Clang or a gcc-compatible C compiler and assembler (other compilers may work).
  • The Perl programming language.
  • The Findlib package manager (optional, recommended).
INSTALLATION
  1. First, run the "configure" script by typing:
 ./configure

The configure script has a few options. Use the -help option to get a
list and short description of each option.
  1. It creates a Makefile, which can be invoked by:
 make

This builds native and bytecode versions of the library.
  1. The libraries are installed by typing:
 make install

or, if you install to a system location but are not an administrator
 sudo make install

If Findlib is detected, it is used to install files.
Otherwise, the files are copied to a zarith/ subdirectory of the directory
given by ocamlc -where.
The libraries are named zarith.cmxa and zarith.cma, and the Findlib module
is named zarith.
Compiling and linking with the library requires passing the -I +zarith
option to ocamlc / ocamlopt, or the -package zarith option to ocamlfind.
  1. (optional, recommended) Test programs are built and run by the additional command
 make tests

(but these are not installed).
  1. (optional) HTML API documentation is built (using ocamldoc) by the additional command
 make doc

LICENSE
This Library is distributed under the terms of the GNU Library General
Public License version 2, with a special exception allowing unconstrained
static linking.
See LICENSE file for details.
AUTHORS
  • Antoine Miné, Université Pierre et Marie Curie, formerly ENS Paris.
  • Xavier Leroy, INRIA Paris-Rocquencourt.
  • Pascal Cuoq, CEA LIST.
  • Christophe Troestler (toplevel module)
COPYRIGHT
Copyright (c) 2010-2011 Antoine Miné, Abstraction project.
Abstraction is part of the LIENS (Laboratoire d'Informatique de l'ENS),
a joint laboratory by:
CNRS (Centre national de la recherche scientifique, France),
ENS (École normale supérieure, Paris, France),
INRIA Rocquencourt (Institut national de recherche en informatique, France).
CONTENTS
Source filesDescription
configureconfiguration script
caml_z.cC implementation of all functions
caml_z_*.Sasm implementation for a few functions
z_pp.plscript to generate z.ml[i] from z.ml[i]p
z.ml[i]ptemplates used to generate z.ml[i]p
big_int_z.ml[i]wrapper to provide a Big_int compatible API to Z
q.ml[i]rational library, pure OCaml on top of Z
zarith_top.mltoplevel module to provide pretty-printing
projet.makbuilds Z, Q and the tests
tests/simple regression tests and benchmarks
Note: z_pp.pl simply scans the asm file (if any) to see which functions have
an asm implementation. It then fixes the external statements in .mlp and
.mlip accordingly.
The argument to z_pp.pl is the suffix * of the caml_z_*.S to use (guessed by configure).
About
The Zarith library implements arithmetic and logical operations over arbitrary-precision integers and rational numbers. The implementation, based on GMP, is very efficient.
Resources
Readme
License
Activity
Custom properties
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
The Zarith library
OVERVIEW
This library implements arithmetic and logical operations over
arbitrary-precision integers.
The module is simply named Z. Its interface is similar to that of
the Int32, Int64 and Nativeint modules from the OCaml standard
library, with some additional functions. See the file z.mlip for
documentation.
The implementation uses GMP (the GNU Multiple Precision arithmetic
library) to compute over big integers.
However, small integers are represented as unboxed Caml integers, to save
space and improve performance. Big integers are allocated in the Caml heap,
bypassing GMP's memory management and achieving better GC behavior than e.g.
the MLGMP library.
Computations on small integers use a special, faster path (coded in assembly
for some platforms and functions) eschewing calls to GMP, while computations
on large intergers use the low-level MPN functions from GMP.
Arbitrary-precision integers can be compared correctly using OCaml's
polymorphic comparison operators (=, <, >, etc.).
This requires OCaml version 3.12.1 or later, though.
Additional features include:
  • a module Q for rationals, built on top of Z (see q.mli)
  • a compatibility layer Big_int_Z that implements the same API as Big_int from the legacy Num library, but uses Z internally
REQUIREMENTS
  • OCaml, preferably version 3.12.1 or later. (Earlier versions are usable but generic comparisons will misbehave.)
  • Either the GMP library or the MPIR library, including development files.
  • GCC or Clang or a gcc-compatible C compiler and assembler (other compilers may work).
  • The Perl programming language.
  • The Findlib package manager (optional, recommended).
INSTALLATION
  1. First, run the "configure" script by typing:
 ./configure

The configure script has a few options. Use the -help option to get a
list and short description of each option.
  1. It creates a Makefile, which can be invoked by:
 make

This builds native and bytecode versions of the library.
  1. The libraries are installed by typing:
 make install

or, if you install to a system location but are not an administrator
 sudo make install

If Findlib is detected, it is used to install files.
Otherwise, the files are copied to a zarith/ subdirectory of the directory
given by ocamlc -where.
The libraries are named zarith.cmxa and zarith.cma, and the Findlib module
is named zarith.
Compiling and linking with the library requires passing the -I +zarith
option to ocamlc / ocamlopt, or the -package zarith option to ocamlfind.
  1. (optional, recommended) Test programs are built and run by the additional command
 make tests

(but these are not installed).
  1. (optional) HTML API documentation is built (using ocamldoc) by the additional command
 make doc

LICENSE
This Library is distributed under the terms of the GNU Library General
Public License version 2, with a special exception allowing unconstrained
static linking.
See LICENSE file for details.
AUTHORS
  • Antoine Miné, Université Pierre et Marie Curie, formerly ENS Paris.
  • Xavier Leroy, INRIA Paris-Rocquencourt.
  • Pascal Cuoq, CEA LIST.
  • Christophe Troestler (toplevel module)
COPYRIGHT
Copyright (c) 2010-2011 Antoine Miné, Abstraction project.
Abstraction is part of the LIENS (Laboratoire d'Informatique de l'ENS),
a joint laboratory by:
CNRS (Centre national de la recherche scientifique, France),
ENS (École normale supérieure, Paris, France),
INRIA Rocquencourt (Institut national de recherche en informatique, France).
CONTENTS
Source filesDescription
configureconfiguration script
caml_z.cC implementation of all functions
caml_z_*.Sasm implementation for a few functions
z_pp.plscript to generate z.ml[i] from z.ml[i]p
z.ml[i]ptemplates used to generate z.ml[i]p
big_int_z.ml[i]wrapper to provide a Big_int compatible API to Z
q.ml[i]rational library, pure OCaml on top of Z
zarith_top.mltoplevel module to provide pretty-printing
projet.makbuilds Z, Q and the tests
tests/simple regression tests and benchmarks
Note: z_pp.pl simply scans the asm file (if any) to see which functions have
an asm implementation. It then fixes the external statements in .mlp and
.mlip accordingly.
The argument to z_pp.pl is the suffix * of the caml_z_*.S to use (guessed by configure).
About
The Zarith library implements arithmetic and logical operations over arbitrary-precision integers and rational numbers. The implementation, based on GMP, is very efficient.
Resources
Readme
License
Activity
Custom properties
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default");
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
The Zarith library
OVERVIEW
This library implements arithmetic and logical operations over
arbitrary-precision integers.
The module is simply named Z. Its interface is similar to that of
the Int32, Int64 and Nativeint modules from the OCaml standard
library, with some additional functions. See the file z.mlip for
documentation.
The implementation uses GMP (the GNU Multiple Precision arithmetic
library) to compute over big integers.
However, small integers are represented as unboxed Caml integers, to save
space and improve performance. Big integers are allocated in the Caml heap,
bypassing GMP's memory management and achieving better GC behavior than e.g.
the MLGMP library.
Computations on small integers use a special, faster path (coded in assembly
for some platforms and functions) eschewing calls to GMP, while computations
on large intergers use the low-level MPN functions from GMP.
Arbitrary-precision integers can be compared correctly using OCaml's
polymorphic comparison operators (=, <, >, etc.).
This requires OCaml version 3.12.1 or later, though.
Additional features include:
  • a module Q for rationals, built on top of Z (see q.mli)
  • a compatibility layer Big_int_Z that implements the same API as Big_int from the legacy Num library, but uses Z internally
REQUIREMENTS
  • OCaml, preferably version 3.12.1 or later. (Earlier versions are usable but generic comparisons will misbehave.)
  • Either the GMP library or the MPIR library, including development files.
  • GCC or Clang or a gcc-compatible C compiler and assembler (other compilers may work).
  • The Perl programming language.
  • The Findlib package manager (optional, recommended).
INSTALLATION
  1. First, run the "configure" script by typing:
 ./configure

The configure script has a few options. Use the -help option to get a
list and short description of each option.
  1. It creates a Makefile, which can be invoked by:
 make

This builds native and bytecode versions of the library.
  1. The libraries are installed by typing:
 make install

or, if you install to a system location but are not an administrator
 sudo make install

If Findlib is detected, it is used to install files.
Otherwise, the files are copied to a zarith/ subdirectory of the directory
given by ocamlc -where.
The libraries are named zarith.cmxa and zarith.cma, and the Findlib module
is named zarith.
Compiling and linking with the library requires passing the -I +zarith
option to ocamlc / ocamlopt, or the -package zarith option to ocamlfind.
  1. (optional, recommended) Test programs are built and run by the additional command
 make tests

(but these are not installed).
  1. (optional) HTML API documentation is built (using ocamldoc) by the additional command
 make doc

LICENSE
This Library is distributed under the terms of the GNU Library General
Public License version 2, with a special exception allowing unconstrained
static linking.
See LICENSE file for details.
AUTHORS
  • Antoine Miné, Université Pierre et Marie Curie, formerly ENS Paris.
  • Xavier Leroy, INRIA Paris-Rocquencourt.
  • Pascal Cuoq, CEA LIST.
  • Christophe Troestler (toplevel module)
COPYRIGHT
Copyright (c) 2010-2011 Antoine Miné, Abstraction project.
Abstraction is part of the LIENS (Laboratoire d'Informatique de l'ENS),
a joint laboratory by:
CNRS (Centre national de la recherche scientifique, France),
ENS (École normale supérieure, Paris, France),
INRIA Rocquencourt (Institut national de recherche en informatique, France).
CONTENTS
Source filesDescription
configureconfiguration script
caml_z.cC implementation of all functions
caml_z_*.Sasm implementation for a few functions
z_pp.plscript to generate z.ml[i] from z.ml[i]p
z.ml[i]ptemplates used to generate z.ml[i]p
big_int_z.ml[i]wrapper to provide a Big_int compatible API to Z
q.ml[i]rational library, pure OCaml on top of Z
zarith_top.mltoplevel module to provide pretty-printing
projet.makbuilds Z, Q and the tests
tests/simple regression tests and benchmarks
Note: z_pp.pl simply scans the asm file (if any) to see which functions have
an asm implementation. It then fixes the external statements in .mlp and
.mlip accordingly.
The argument to z_pp.pl is the suffix * of the caml_z_*.S to use (guessed by configure).
About
The Zarith library implements arithmetic and logical operations over arbitrary-precision integers and rational numbers. The implementation, based on GMP, is very efficient.
Resources
Readme
License
Activity
Custom properties
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers");
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
The Zarith library
OVERVIEW
This library implements arithmetic and logical operations over
arbitrary-precision integers.
The module is simply named Z. Its interface is similar to that of
the Int32, Int64 and Nativeint modules from the OCaml standard
library, with some additional functions. See the file z.mlip for
documentation.
The implementation uses GMP (the GNU Multiple Precision arithmetic
library) to compute over big integers.
However, small integers are represented as unboxed Caml integers, to save
space and improve performance. Big integers are allocated in the Caml heap,
bypassing GMP's memory management and achieving better GC behavior than e.g.
the MLGMP library.
Computations on small integers use a special, faster path (coded in assembly
for some platforms and functions) eschewing calls to GMP, while computations
on large intergers use the low-level MPN functions from GMP.
Arbitrary-precision integers can be compared correctly using OCaml's
polymorphic comparison operators (=, <, >, etc.).
This requires OCaml version 3.12.1 or later, though.
Additional features include:
  • a module Q for rationals, built on top of Z (see q.mli)
  • a compatibility layer Big_int_Z that implements the same API as Big_int from the legacy Num library, but uses Z internally
REQUIREMENTS
  • OCaml, preferably version 3.12.1 or later. (Earlier versions are usable but generic comparisons will misbehave.)
  • Either the GMP library or the MPIR library, including development files.
  • GCC or Clang or a gcc-compatible C compiler and assembler (other compilers may work).
  • The Perl programming language.
  • The Findlib package manager (optional, recommended).
INSTALLATION
  1. First, run the "configure" script by typing:
 ./configure

The configure script has a few options. Use the -help option to get a
list and short description of each option.
  1. It creates a Makefile, which can be invoked by:
 make

This builds native and bytecode versions of the library.
  1. The libraries are installed by typing:
 make install

or, if you install to a system location but are not an administrator
 sudo make install

If Findlib is detected, it is used to install files.
Otherwise, the files are copied to a zarith/ subdirectory of the directory
given by ocamlc -where.
The libraries are named zarith.cmxa and zarith.cma, and the Findlib module
is named zarith.
Compiling and linking with the library requires passing the -I +zarith
option to ocamlc / ocamlopt, or the -package zarith option to ocamlfind.
  1. (optional, recommended) Test programs are built and run by the additional command
 make tests

(but these are not installed).
  1. (optional) HTML API documentation is built (using ocamldoc) by the additional command
 make doc

LICENSE
This Library is distributed under the terms of the GNU Library General
Public License version 2, with a special exception allowing unconstrained
static linking.
See LICENSE file for details.
AUTHORS
  • Antoine Miné, Université Pierre et Marie Curie, formerly ENS Paris.
  • Xavier Leroy, INRIA Paris-Rocquencourt.
  • Pascal Cuoq, CEA LIST.
  • Christophe Troestler (toplevel module)
COPYRIGHT
Copyright (c) 2010-2011 Antoine Miné, Abstraction project.
Abstraction is part of the LIENS (Laboratoire d'Informatique de l'ENS),
a joint laboratory by:
CNRS (Centre national de la recherche scientifique, France),
ENS (École normale supérieure, Paris, France),
INRIA Rocquencourt (Institut national de recherche en informatique, France).
CONTENTS
Source filesDescription
configureconfiguration script
caml_z.cC implementation of all functions
caml_z_*.Sasm implementation for a few functions
z_pp.plscript to generate z.ml[i] from z.ml[i]p
z.ml[i]ptemplates used to generate z.ml[i]p
big_int_z.ml[i]wrapper to provide a Big_int compatible API to Z
q.ml[i]rational library, pure OCaml on top of Z
zarith_top.mltoplevel module to provide pretty-printing
projet.makbuilds Z, Q and the tests
tests/simple regression tests and benchmarks
Note: z_pp.pl simply scans the asm file (if any) to see which functions have
an asm implementation. It then fixes the external statements in .mlp and
.mlip accordingly.
The argument to z_pp.pl is the suffix * of the caml_z_*.S to use (guessed by configure).
About
The Zarith library implements arithmetic and logical operations over arbitrary-precision integers and rational numbers. The implementation, based on GMP, is very efficient.
Resources
Readme
License
Activity
Custom properties
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode");
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
The Zarith library
OVERVIEW
This library implements arithmetic and logical operations over
arbitrary-precision integers.
The module is simply named Z. Its interface is similar to that of
the Int32, Int64 and Nativeint modules from the OCaml standard
library, with some additional functions. See the file z.mlip for
documentation.
The implementation uses GMP (the GNU Multiple Precision arithmetic
library) to compute over big integers.
However, small integers are represented as unboxed Caml integers, to save
space and improve performance. Big integers are allocated in the Caml heap,
bypassing GMP's memory management and achieving better GC behavior than e.g.
the MLGMP library.
Computations on small integers use a special, faster path (coded in assembly
for some platforms and functions) eschewing calls to GMP, while computations
on large intergers use the low-level MPN functions from GMP.
Arbitrary-precision integers can be compared correctly using OCaml's
polymorphic comparison operators (=, <, >, etc.).
This requires OCaml version 3.12.1 or later, though.
Additional features include:
  • a module Q for rationals, built on top of Z (see q.mli)
  • a compatibility layer Big_int_Z that implements the same API as Big_int from the legacy Num library, but uses Z internally
REQUIREMENTS
  • OCaml, preferably version 3.12.1 or later. (Earlier versions are usable but generic comparisons will misbehave.)
  • Either the GMP library or the MPIR library, including development files.
  • GCC or Clang or a gcc-compatible C compiler and assembler (other compilers may work).
  • The Perl programming language.
  • The Findlib package manager (optional, recommended).
INSTALLATION
  1. First, run the "configure" script by typing:
 ./configure

The configure script has a few options. Use the -help option to get a
list and short description of each option.
  1. It creates a Makefile, which can be invoked by:
 make

This builds native and bytecode versions of the library.
  1. The libraries are installed by typing:
 make install

or, if you install to a system location but are not an administrator
 sudo make install

If Findlib is detected, it is used to install files.
Otherwise, the files are copied to a zarith/ subdirectory of the directory
given by ocamlc -where.
The libraries are named zarith.cmxa and zarith.cma, and the Findlib module
is named zarith.
Compiling and linking with the library requires passing the -I +zarith
option to ocamlc / ocamlopt, or the -package zarith option to ocamlfind.
  1. (optional, recommended) Test programs are built and run by the additional command
 make tests

(but these are not installed).
  1. (optional) HTML API documentation is built (using ocamldoc) by the additional command
 make doc

LICENSE
This Library is distributed under the terms of the GNU Library General
Public License version 2, with a special exception allowing unconstrained
static linking.
See LICENSE file for details.
AUTHORS
  • Antoine Miné, Université Pierre et Marie Curie, formerly ENS Paris.
  • Xavier Leroy, INRIA Paris-Rocquencourt.
  • Pascal Cuoq, CEA LIST.
  • Christophe Troestler (toplevel module)
COPYRIGHT
Copyright (c) 2010-2011 Antoine Miné, Abstraction project.
Abstraction is part of the LIENS (Laboratoire d'Informatique de l'ENS),
a joint laboratory by:
CNRS (Centre national de la recherche scientifique, France),
ENS (École normale supérieure, Paris, France),
INRIA Rocquencourt (Institut national de recherche en informatique, France).
CONTENTS
Source filesDescription
configureconfiguration script
caml_z.cC implementation of all functions
caml_z_*.Sasm implementation for a few functions
z_pp.plscript to generate z.ml[i] from z.ml[i]p
z.ml[i]ptemplates used to generate z.ml[i]p
big_int_z.ml[i]wrapper to provide a Big_int compatible API to Z
q.ml[i]rational library, pure OCaml on top of Z
zarith_top.mltoplevel module to provide pretty-printing
projet.makbuilds Z, Q and the tests
tests/simple regression tests and benchmarks
Note: z_pp.pl simply scans the asm file (if any) to see which functions have
an asm implementation. It then fixes the external statements in .mlp and
.mlip accordingly.
The argument to z_pp.pl is the suffix * of the caml_z_*.S to use (guessed by configure).
About
The Zarith library implements arithmetic and logical operations over arbitrary-precision integers and rational numbers. The implementation, based on GMP, is very efficient.
Resources
Readme
License
Activity
Custom properties
Stars
0 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages