package octez-bls12-381-polynomial

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Parameters
Signature

octez-bls12-381-polynomial
- Octez_bls12_381_polynomial
  - Bls12_381_polynomial
    
    Domain
    
    Evaluations
    
    G1_carray
    
    G2_carray
    
    Polynomial
    
    S
    
    Domain
    
    Evaluations
    
    G1_carray
    
    G2_carray
    
    Polynomial
    
    Srs
    
    Srs_g1
    
    Srs_g2
    
    Srs
    
    Srs_g1
    
    Srs_g2
  - Carray
    
    Carray_sig
    
    Elt_sig
    
    Make
    
    Elt
  - Domain
    
    Domain_impl
    
    Domain_sig
    
    Domain_unsafe
    
    Domain_unsafe_sig
    
    Stubs
  - Ec_carray
    
    EC_carray_sig
    
    G1_Elt
    
    G1_array_internal
    
    G1_carray
    
    G2_Elt
    
    G2_array_internal
    
    G2_carray
    
    Make
    
    EC_point
    
    Scalar
    
    EC_point_array
    
    Stubs
    
    Stubs_g1
    
    Stubs_g2
    
    Stubs_sig
  - Evaluations
    
    Evaluations_impl
    
    Evaluations_sig
    
    Evaluations_unsafe
    
    Evaluations_unsafe_sig
    
    Stubs
  - Fr_carray
    
    Elt
  - Helpers
  - Polynomial
    
    Polynomial_impl
    
    Polynomial_sig
    
    Polynomial_unsafe
    
    Polynomial_unsafe_sig
    
    Stubs
  - Srs
    
    Checks
    
    Elt_g1
    
    Elt_g2
    
    GElt_sig
    
    G
    
    Scalar
    
    Make
    
    Carray
    
    Elt
    
    G
    
    Scalar
    
    S
    
    S_unsafe
    
    Srs
    
    Srs_g1
    
    Srs_g2

Legend:
Library
Module
Module type
Parameter
Class
Class type

Parameters

module EC_point : Bls12_381.CURVE

module EC_point_array : Carray.Carray_sig with type elt = EC_point.t

module Stubs : 
  Stubs_sig
    with type fr_array = Fr_carray.t
     and type ec_array = EC_point_array.t

Signature

include Carray.Carray_sig with type elt = EC_point.t

type t

type elt = EC_point.t

val t : t Repr.t

val empty : t

val allocate : int -> t

allocate len creates a C array of size len initialized with zeros.

val init : int -> (int -> elt) -> t

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

val degree : t -> int

degree p returns the index of the last non-zero element of p. Returns -1 if all elements of p are zero.

val erase : t -> int -> unit

erase p n fills with zeros the first n elements of p.

val length : t -> int

length c returns the length of a C array c

val get : t -> int -> elt

get c i returns the i-th element of a C array c

val get_inplace : t -> int -> elt -> unit

get_inplace c i res copies the i-th element of a C array c in res

val iter_copy_elt : (elt -> unit) -> t -> unit

iter_copy_elt f a applies function f in turn to a **copy** of all the elements of a. It is equivalent to f a.(0); f a.(1); ...; f a.(length a - 1); ().

val iteri_copy_elt : (int -> elt -> unit) -> t -> unit

Same as iter_copy_elt, but the function is applied to the index of the element as first argument, and a **copy** of the element itself as second argument.

val set : t -> elt -> int -> unit

val copy : ?offset:int -> ?len:int -> t -> t

copy c copies len elements from a C array c starting from position offset

val blit : t -> src_off:int -> t -> dst_off:int -> len:int -> unit

blit src src_off dst dst_off len copies len elements from src to dst starting at the respective offsets.

val equal : t -> offset1:int -> t -> offset2:int -> len:int -> bool

equal a offset1 b offset2 returns true if the segments of len elements of a and b are equal starting from their respective offsets offset1 (for a) and offset2 (for b).

val to_array : ?offset:int -> ?len:int -> t -> elt array

to_array c converts a C array c to an OCaml array

val of_array : elt array -> t

of_array c converts an OCaml array c to a C array

val of_bigstring : Bigstringaf.t -> t

val to_bigstring : t -> Bigstringaf.t

val eq : t -> t -> bool

eq a b returns true if C arrays a and b are equals

val sub : t -> off:int -> len:int -> t

sub a off len extracts a sub-array of a

val fold_left_map : ('acc -> elt -> 'acc * elt) -> 'acc -> t -> 'acc * t

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

type domain = Domain.t

val evaluation_ecfft : domain:domain -> points:t -> t

evaluation_ecfft domain points computes the ECFFT. domain can be obtained using Domain.build.

The ECFFT computes the G-linear map G^n -> G^n : (P_i)_=0,...,n-1 |-> (sum_=0^n-1 domain.(i*j mod n)P_i)_j=0,...,n-1.

where aP denotes the elliptic curve point multiplication.

Note:

size of domain must be a power of two
degree of polynomial must be strictly less than the size of domain

val interpolation_ecfft_inplace : domain:domain -> points:t -> unit

interpolation_ecfft_inplace domain points computes the inverse ECFFT. domain can be obtained using Domain.build.

It is the inverse function of evaluation_ecfft_inplace.

Note:

size of domain must be a power of two
size of a polynomial must be equal to size of domain

val add_arrays_inplace : t -> t -> unit

add_arrays_inplace a b writes the element-wise sum of the input vectors a and b into a

type evaluations = Evaluations.t

val mul_arrays : evaluations:evaluations array -> arrays:t array -> t array

mul_arrays evaluations arrays computes the EC point multiplication given the scalar multipliers evaluations and the points arrays