pbc_field.h

这是一个C的源代码

/*
 * Though this data structure does represent fields,
 * we also use it for rings and groups as well.
 */
//requires
// * stdio.h
// * gmp.h
#ifndef __PBC_FIELD_H__
#define __PBC_FIELD_H__

struct field_s;

struct element_s {
    struct field_s *field;
    void *data;
};
typedef struct element_s *element_ptr;
typedef struct element_s element_t[1];

struct element_pp_s {
    struct field_s *field;
    void *data;
};
typedef struct element_pp_s element_pp_t[1];
typedef struct element_pp_s *element_pp_ptr;

#include "pbc_assert.h"
void pbc_assert(int expr, char *msg, const char *func);
void pbc_assert_match2(element_ptr a, element_ptr b, const char *func);
void pbc_assert_match3(element_ptr a, element_ptr b, element_ptr c, const char *func);

struct pairing_s;

struct field_s {
    void (*field_clear)(struct field_s *f);
    void (*init)(element_ptr);
    void (*clear)(element_ptr);
    void (*set_si)(element_ptr, signed long int);
    void (*set_mpz)(element_ptr, mpz_ptr);
    void (*set)(element_ptr, element_ptr);
    void (*set0)(element_ptr);
    void (*set1)(element_ptr);
    size_t (*out_str)(FILE *stream, int base, element_ptr);
    void (*add)(element_ptr, element_ptr, element_ptr);
    void (*add_ui)(element_ptr, element_ptr, unsigned long int);
    void (*sub)(element_ptr, element_ptr, element_ptr);
    void (*mul)(element_ptr, element_ptr, element_ptr);
    void (*mul_mpz)(element_ptr, element_ptr, mpz_ptr);
    void (*mul_si)(element_ptr, element_ptr, signed long int);
    void (*div)(element_ptr, element_ptr, element_ptr);
    void (*square)(element_ptr, element_ptr);
    int (*is_sqr)(element_ptr);
    void (*sqrt)(element_ptr, element_ptr);
    void (*doub)(element_ptr, element_ptr); //can't call it "double"!
    void (*halve)(element_ptr, element_ptr);
    void (*pow_mpz)(element_ptr, element_ptr, mpz_ptr);
    void (*invert)(element_ptr, element_ptr);
    void (*neg)(element_ptr, element_ptr);
    void (*random)(element_ptr);
    void (*from_hash)(element_ptr, void *data, int len);
    int (*is1)(element_ptr);
    int (*is0)(element_ptr);
    int (*sign)(element_ptr); //satisfies sign(x) = -sign(-x)
    int (*cmp)(element_ptr, element_ptr);
    int (*to_bytes)(unsigned char *data, element_ptr);
    int (*from_bytes)(element_ptr, unsigned char *data);
    int (*length_in_bytes)(element_ptr);
    int fixed_length_in_bytes; //length of an element in bytes; -1 for variable
    mpz_t order; //0 for infinite order
    element_ptr nqr; //nonquadratic residue
    void (*to_mpz)(mpz_ptr, element_ptr);
    void (*out_info)(FILE *, struct field_s *);
    void (*pp_init)(element_pp_t p, element_t in);
    void (*pp_clear)(element_pp_t p);
    void (*pp_pow)(element_t out, mpz_ptr power, element_pp_t p);
    int (*snprint)(char *s, size_t n, element_ptr e);
    int (*set_str)(element_ptr e, char *s, int base);
    struct pairing_s *pairing;
    void *data;
};
typedef struct field_s *field_ptr;
typedef struct field_s field_t[1];

typedef void (*fieldmap)(element_t dst, element_t src);

/*@manual internal
Initialize ''e'' to be an element of the algebraic structure ''f''
and set it to be the zero element.
*/
static inline void element_init(element_t e, field_ptr f)
{
    e->field = f;
    f->init(e);
}

/*@manual einit
Initialize ''e'' to be an element of the algebraic structure that ''e2''
lies in.
*/
static inline void element_init_same_as(element_t e, element_t e2)
{
    element_init(e, e2->field);
}

/*@manual einit
Free the space occupied by ''e''. Call this when
the variable ''e'' is no longer needed.
*/
static inline void element_clear(element_t e)
{
    e->field->clear(e);
}

/*@manual eio
Output ''e'' on ''stream'' in base ''base''. The base must be between
2 and 36.
*/
static inline size_t element_out_str(FILE *stream, int base, element_t e)
{
    return e->field->out_str(stream, base, e);
}

/*@manual eio
*/
int element_printf(const char *format, ...);

/*@manual eio
*/
int element_fprintf(FILE *stream, const char *format, ...);

/*@manual eio
Same as printf family
except also has the 'B' conversion specifier for types
of <function>element_t</function>, and 'Y', 'Z' conversion specifiers for
<type>mpz_t</type>. For example if ''e'' is of type
<type>element_t</type> then
<screen>
element_printf("%B\n", e);
</screen>
will print the value of ''e'' in a human-readable form on standard output.
*/
int element_snprintf (char *buf, size_t size, const char *fmt, ...);

/*@manual eio
Convert an element to a human-friendly string.
Behaves as <function>snprintf</function> but only on one element at a time.
*/
static inline int element_snprint(char *s, size_t n, element_t e)
{
    return e->field->snprint(s, n, e);
}

/*@manual eio
Set the element ''e'' from ''s'', a null-terminated C string in base 'base'.
Whitespace is ignored. Points have the form "[''x,y'']" or "''O''",
while polynomials have the form "[''a0,...,an'']".
Returns number of characters read (unlike GMP's mpz_set_str).
A return code of zero means PBC could not find a well-formed string
describing an element.
*/
static inline int element_set_str(element_t e, char *s, int base)
{
    return e->field->set_str(e, s, base);
}

/*@manual eassign
Set ''e'' to zero.
*/
static inline void element_set0(element_t e)
{
    e->field->set0(e);
}

/*@manual eassign
Set ''e'' to one.
*/
static inline void element_set1(element_t e)
{
    e->field->set1(e);
}

/*@manual eassign
Set ''e'' to ''i''.
*/
static inline void element_set_si(element_t e, signed long int i)
{
    e->field->set_si(e, i);
}

/*@manual eassign
Set ''e'' to ''z''.
*/
static inline void element_set_mpz(element_t e, mpz_t z)
{
    e->field->set_mpz(e, z);
}

/*@manual eassign
Set ''e'' to ''a''.
*/
static inline void element_set(element_t e, element_t a)
{
    PBC_ASSERT_MATCH2(e, a);
    e->field->set(e, a);
}

static inline void element_add_ui(element_t n, element_t a, unsigned long int b)
{
    n->field->add_ui(n, a, b);
}

/*@manual econvert
Converts ''e'' to a GMP integer ''z''
if such an operation makes sense
*/
static inline void element_to_mpz(mpz_t z, element_t e)
{
    e->field->to_mpz(z, e);
}

/*@manual econvert
Generate an element ''e'' deterministically from
the ''len'' bytes stored in the buffer ''data''.
*/
static inline void element_from_hash(element_t e, void *data, int len)
{
    e->field->from_hash(e, data, len);
}
/*@manual earith
Set ''n'' to ''a'' + ''b''.
*/
static inline void element_add(element_t n, element_t a, element_t b)
{
    PBC_ASSERT_MATCH3(n, a, b);
    n->field->add(n, a, b);
}

/*@manual earith
Set ''n'' to ''a'' - ''b''.
*/
static inline void element_sub(element_t n, element_t a, element_t b)
{
    PBC_ASSERT_MATCH3(n, a, b);
    n->field->sub(n, a, b);
}

/*@manual earith
Set ''n'' to ''a'' times ''b''.
*/
static inline void element_mul(element_t n, element_t a, element_t b)
{
    PBC_ASSERT_MATCH3(n, a, b);
    n->field->mul(n, a, b);
}

/*@manual earith
*/
static inline void element_mul_mpz(element_t n, element_t a, mpz_t z)
{
    PBC_ASSERT_MATCH2(n, a);
    n->field->mul_mpz(n, a, z);
}

/*@manual earith
''z'' must be a mpz_t/signed long int.
Set ''n'' to ''a'' times ''z'', that is ''a'' + ''a'' + ... + ''a''
where there are ''z'' ''a'''s.
*/
static inline void element_mul_si(element_t n, element_t a, signed long int z) 
{
    PBC_ASSERT_MATCH2(n, a);
    n->field->mul_si(n, a, z);
}

/*@manual earith
''z'' must be an element of a integer mod ring (i.e. Z_n for some n).
Set ''c'' to ''a'' times ''z'', that is ''a'' + ''a'' + ... + ''a''
where there are ''z'' ''a'''s.
*/
static inline void element_mul_zn(element_t c, element_t a, element_t z)
{
    mpz_t z0;
    PBC_ASSERT_MATCH2(c, a);
    //TODO: check z->field is Zn
    mpz_init(z0);
    element_to_mpz(z0, z);
    element_mul_mpz(c, a, z0);
    mpz_clear(z0);
}

/*@manual earith
Set ''n'' to ''a'' / ''b''.
*/
static inline void element_div(element_t n, element_t a, element_t b)
{
    PBC_ASSERT_MATCH3(n, a, b);
    n->field->div(n, a, b);
}

/*@manual earith
Set ''n'' to ''a'' + ''a''.
*/
static inline void element_double(element_t n, element_t a)
{
    PBC_ASSERT_MATCH2(n, a);
    n->field->doub(n, a);
}