package octez-libs

  1. Overview
  2. No Docs
A package that contains multiple base libraries used by the Octez suite

Install 

dune-project
 Dependency

www.tezos.com Edit opam file Versions (5)

Authors

  1. T
    Tezos devteam

Maintainers

  1. C
    contact@tezos.com

Sources

tezos-18.1.tar.gz
sha256=aa2f5bc99cc4ca2217c52a1af2a2cdfd3b383208cb859ca2e79ca0903396ca1d
sha512=d68bb3eb615e3dcccc845fddfc9901c95b3c6dc8e105e39522ce97637b1308a7fa7aa1d271351d5933febd7476b2819e1694f31198f1f0919681f1f9cc97cb3a

doc/octez-libs.bls12-381-polynomial/Octez_bls12_381_polynomial/Polynomial/index.html

Module Octez_bls12_381_polynomial.PolynomialSource

This library implements polynomials of Bls12_381.Fr as arrays of contiguous memory in C, allowing much better performances for algorithms that scan the polynomials.

An array a of size n represents the polynomial $\sum_i^(n-1) ai X^i$ The length of a is always greater or equal than the degree+1 of its corresponding polynomial, if greater it padded with zeros. As a consequence a polynomial has many representations, namely all arrays with trailing zeros.

Sourcetype scalar = scalar
Sourcetype t
Sourceval t : t Repr.t
Sourceval init : int -> (int -> scalar) -> t

init n f returns a fresh polynomial of length n, with element number i initialized to the result of f i.

Sourceval allocate : int -> t

allocate len creates a zero polynomial of size len

Sourceval erase : t -> unit

erase p overwrites a polynomial p with a zero polynomial of the same size as the polynomial p

Sourceval generate_biased_random_polynomial : int -> t

generate_biased_random_polynomial n generates a random polynomial of degree strictly lower than n, the distribution is NOT uniform, it is biased towards sparse polynomials and particularly towards the zero polynomial

Sourceval random : int -> t

random n generates a uniformly sampled polynomial among the set of all polynomials of degree strictly lower than n

Sourceval degree : t -> int

degree p returns the degree of a polynomial p. Returns -1 for the zero polynomial

Sourceval get : t -> int -> scalar

get p i returns the i-th element of a given array p, a coefficient of X^i in p

Sourceval to_string : t -> string

to_string p returns the string representation of a polynomial p

Sourceval copy : t -> t

copy p returns a copy of a polynomial p

Sourceval truncate : len:int -> t -> t

truncate ~len p returns a new polynomial made of the first len coefficients of p. If degree p + 1 is less than len then copy p is returned.

  • raises [Invalid_argument]

    if len is negative.

Sourceval to_dense_coefficients : t -> scalar array

to_dense_coefficients p returns the dense representation of a polynomial p, i.e., it converts a C array to an OCaml array

Sourceval of_dense : scalar array -> t

of_dense p creates a value of type t from the dense representation of a polynomial p, i.e., it converts an OCaml array to a C array

Sourceval of_coefficients : (scalar * int) list -> t

of_coefficients p creates a value of type t from the sparse representation of a polynomial p, i.e., it converts an OCaml array to a C array

Sourceval equal : t -> t -> bool

equal a b checks whether a polynomial a is equal to a polynomial b

Sourceval is_zero : t -> bool

is_zero p checks whether a polynomial p is the zero polynomial

Sourceval zero : t

zero is the zero polynomial, the neutral element for polynomial addition

Sourceval one : t

one is the constant polynomial one, the neutral element for polynomial multiplication

Sourceval add : t -> t -> t

add computes polynomial addition

Sourceval add_inplace : t -> t -> t -> unit

add_inplace res a b computes polynomial addition of a and b and writes the result in res

Note: res can be equal to either a or b

Sourceval sub : t -> t -> t

sub computes polynomial subtraction

Sourceval sub_inplace : t -> t -> t -> unit

sub_inplace res a b computes polynomial subtraction of a and b and writes the result in res

Note: res can be equal to either a or b

Sourceval mul : t -> t -> t

mul computes polynomial multiplication

Note: naive quadratic algorithm, result's size is the sum of arguments' size

Sourceval mul_by_scalar : scalar -> t -> t

mul_by_scalar computes multiplication of a polynomial by a blst_fr element

Sourceval mul_by_scalar_inplace : t -> scalar -> t -> unit

mul_by_scalar_inplace res s p computes multiplication of a polynomial p by a blst_fr element s and stores it in res

Sourceval linear : t list -> scalar list -> t

linear p s computes ∑ᵢ s.(i)·p.(i)

Sourceval linear_with_powers : t list -> scalar -> t

linear_with_powers p s computes ∑ᵢ sⁱ·p.(i). This function is more efficient than linear + powers

Sourceval opposite : t -> t

opposite computes polynomial negation

Sourceval opposite_inplace : t -> unit

opposite_inplace p computes polynomial negation

Note: The argument p is overwritten

Sourceval evaluate : t -> scalar -> scalar

evaluate p x evaluates a polynomial p at x

Sourceexception Rest_not_null of string
Sourceval division_xn : t -> int -> scalar -> t * t

division_xn p n c returns the quotient and remainder of the division of p by (X^n + c)

Sourceval mul_xn : t -> int -> scalar -> t

mul_xn p n c returns the product of p and (X^n + c)

Sourceval derivative : t -> t

derivative p returns the formal derivative of p

Sourceval split : nb_chunks:int -> int -> t -> t list
Sourceval blind : nb_blinds:int -> int -> t -> t * t

blind ~nb_blinds n p adds to polynomial p a random multiple of polynomial (X^n - 1), chosen by uniformly sampling a polynomial b of degree strictly lower than nb_blinds and multiplying it by (X^n - 1), b is returned as the second argument

Sourceval (=) : t -> t -> bool

Infix operator for equal

Sourceval (+) : t -> t -> t

Infix operator for add

Sourceval (-) : t -> t -> t

Infix operator for sub

Sourceval (*) : t -> t -> t

Infix operator for mul

Sourceval constant : scalar -> t

constant s creates a value of type t from a blst_fr element s

Sourceval fold_left_map : ('acc -> scalar -> 'acc * scalar) -> 'acc -> t -> 'acc * t

fold_left_map is a combination of fold_left and map that threads an accumulator through calls to f.