mphell-field.h

Go to the documentation of this file.

/* 
  MPHELL-5.0 
  Author(s): The MPHELL team
 
 (C) Copyright 2015-2021 - Institut Fourier / Univ. Grenoble Alpes (France) 
 
 This file is part of the MPHELL Library.
 MPHELL is free software: you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation, version 3 of the License.
 
 MPHELL is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public License
 along with MPHELL.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef MPHELL_FIELD_H
#define MPHELL_FIELD_H
 
#include "mphell-fp.h"
#include "mphell-fp2.h"
#include "mphell-fp3.h"
 
typedef fp_elt * field_elt;
 
typedef fp_elt * fe_ptr;
 
typedef const fp_elt * fe_srcptr;
 
typedef enum
{
    FP,     
    FP2,    
    FP3     
} field_type;
 
typedef struct
{
    void *param;                        
    field_type type;                    
    uint8_t size;                       
    uint16_t bit_size;                  
    field_elt pool_1[POOL_SIZE_FIELD];  
    uint8_t i_1;                        
#if MPHELL_USE_MULTITHREADING == 1
    field_elt pool_2[POOL_SIZE_FIELD];  
    uint8_t i_2;                        
#endif
    char id[20];                        
}
field_t;
 
typedef field_t field[1];
 
typedef field_t * field_ptr;
 
typedef const field_t * field_srcptr;
 
/**************************************TMP**********************************/
 
static inline void
field_elt_get_pool_elt (field_elt * dst, field_ptr k, uint8_t stack)
{
#if MPHELL_USE_MULTITHREADING == 0
    MPHELL_ASSERT(stack == STACK_1, "field_elt_get_pool_elt, unknow stack \n");
    MPHELL_ASSERT(k->i_1 < POOL_SIZE_FIELD, "field_elt_get_pool_elt, stack is too small \n");
    *dst = (k->pool_1)[(k->i_1)++];
#elif MPHELL_USE_MULTITHREADING == 1
    if(stack == STACK_1)
    {
        MPHELL_ASSERT(k->i_1 < POOL_SIZE_FIELD, "field_elt_get_pool_elt, stack is too small \n");
        *dst = (k->pool_1)[(k->i_1)++];
    }
    else if (stack == STACK_2)
    {
        MPHELL_ASSERT(k->i_2 < POOL_SIZE_FIELD, "field_elt_get_pool_elt, stack is too small \n");
        *dst = (k->pool_2)[(k->i_2)++];
    }
    else
    {
        *dst = 0;
        mphell_error("field_elt_get_pool_elt, unknow stack \n");
    }
#endif
}
 
static inline void
field_elt_relax_pool_elt (field_elt * dst, field_ptr k, uint8_t stack)
{
#if MPHELL_USE_MULTITHREADING == 0
    MPHELL_ASSERT(stack == STACK_1, "field_elt_relax_pool_elt, unknow stack \n");
    (k->i_1)--;
    MPHELL_ASSERT(k->i_1 >= 0, "k->i_1 is < 0 in pool 1\n");
#elif MPHELL_USE_MULTITHREADING == 1
    if(stack == STACK_1)
    {
        (k->i_1)--;
        MPHELL_ASSERT(k->i_1 >= 0, "k->i_1 is < 0 in pool 1\n");
    }
    else if (stack == STACK_2)
    {
        (k->i_2)--;
        MPHELL_ASSERT(k->i_2 >= 0, "k->i_2 is < 0 in pool 2\n");
    }
    else
    {
        mphell_error("field_elt_relax_pool_elt, unknow stack \n");
    }
#endif
}
 
/************************************SETTERS**********************************/
 
void
field_alloc (field_ptr k, const field_type type, const uint8_t size, field_ptr base);
 
#if MPHELL_USE_AMNS == 1
void
field_set_amns (field_ptr k, amns_ptr AMNS);
#endif
 
void
field_create (field_ptr k, const char* id, uint8_t stack, const uint32_t n, ...); 
 
void
field_copy (field_ptr k_res, field_srcptr k);
 
void
field_free (field_ptr k);
 
void
field_get_size (number_ptr c, field_srcptr k);
 
void
field_get_characteristic (number_ptr c, field_srcptr k);
 
void
field_elt_alloc (fe_ptr * dst, field_srcptr k);
 
void
field_elt_init (fe_ptr dst, field_srcptr k);
 
void
field_elt_copy (fe_ptr dst, fe_srcptr src, field_srcptr k);
 
void
field_elt_clear (fe_ptr * src, field_srcptr k);
 
void
field_elt_free (fe_ptr * src, field_srcptr k);
 
void
field_elt_set_one (fe_ptr dst, field_srcptr k);
 
void
field_elt_set_zero (fe_ptr dst, field_srcptr k);
 
void
field_elt_set_ui (fe_ptr dst, const block src, const bool isreduced,
        field_srcptr k, uint8_t stack);
 
void
field_elt_set_number (fe_ptr dst, const bool isreduced, field_srcptr k,
        uint8_t stack, const uint32_t n, ...);
 
void
field_elt_set_fp_elts (fe_ptr dst, field_srcptr k, const uint32_t n, ...);
 
void
field_elt_set_str (fe_ptr dst, const char *str, const uint8_t base, 
        const bool isreduced, field_srcptr k, uint8_t stack); 
 
void
field_elt_random (fe_ptr dst, field_srcptr k, uint8_t stack);
 
void
field_elt_lift (fe_ptr dst, fe_srcptr src, field_srcptr k, uint8_t stack);
 
void
field_elt_get_number (number_ptr dst, fe_srcptr src, uint8_t pos, field_srcptr k, uint8_t stack);
 
void
field_elt_get_fp_elt (fe_ptr dst, fe_srcptr src, uint8_t pos, field_srcptr k);
 
void
field_str (char **str, field_srcptr k, const uint8_t base, uint8_t stack);
 
void
field_print (field_srcptr k, const uint8_t base, uint8_t stack);
 
void
field_elt_str (char **str, fe_srcptr src, const uint8_t base, const bool lift, field_srcptr k, uint8_t stack);
 
void
field_elt_print (fe_srcptr src, const uint8_t base, const bool lift, field_srcptr k, uint8_t stack);
 
bool 
field_isequal (field_srcptr k1, field_srcptr k2);
 
 
/*************************COMPARISON AND LOGICAL******************************/
 
int8_t
field_elt_cmp (fe_srcptr src1, fe_srcptr src2, field_srcptr k);
 
int8_t
field_elt_cmp_fp_elt (fe_srcptr src1, fe_srcptr src2, field_srcptr k);
 
bool
field_elt_isone (fe_srcptr src, field_srcptr k);
 
static inline bool
field_elt_iszero (fe_srcptr src, field_srcptr k)
{
    bool res = false;
    switch(k->type)
    {
        case FP :
            res = fp_elt_iszero((fp_elt_srcptr)(*src), k->param);
            break;
 
        case FP2 :
            res = fp2_elt_iszero((fp2_elt_srcptr)src, k->param);
            break;
 
        case FP3 :
            res = fp3_elt_iszero((fp3_elt_srcptr)src, k->param);
            break;
    }
    return res;
}
 
 
/***************************ADDITION SUBTRACTION******************************/
 
static inline void
field_elt_inc (fe_ptr dst, fe_srcptr src, field_srcptr k)
{
    switch(k->type)
    {
        case FP :
            fp_elt_inc((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src), k->param);
            break;
        
        case FP2 :
            fp2_elt_inc((fp2_elt_ptr)dst, (fp2_elt_srcptr)src, k->param);
            break;
 
        case FP3 :
            fp3_elt_inc((fp3_elt_ptr)dst, (fp3_elt_srcptr)src, k->param);
            break;
    }
}
 
static inline void
field_elt_add (fe_ptr dst, fe_srcptr src1, fe_srcptr src2, field_srcptr k)
{
    switch(k->type)
    {
        case FP :
            fp_elt_add((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src1), (fp_elt_srcptr)(*src2), k->param);
            break;
 
        case FP2 :
            fp2_elt_add((fp2_elt_ptr)dst, (fp2_elt_srcptr)src1, (fp2_elt_srcptr)src2, k->param);
            break;
 
        case FP3 :
            fp3_elt_add((fp3_elt_ptr)dst, (fp3_elt_srcptr)src1, (fp3_elt_srcptr)src2, k->param);
            break;
    }
}
 
static inline void
field_elt_add_fp_elt (fe_ptr dst, fe_srcptr src1, fe_srcptr src2, field_srcptr k)
{
    switch(k->type)
    {
        case FP :
            fp_elt_add((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src1), (fp_elt_srcptr)(*src2), k->param);
            break;
 
        case FP2 :
            fp2_elt_add_fp_elt((fp2_elt_ptr)dst, (fp2_elt_srcptr)src1, (fp_elt_srcptr)(*src2), k->param);
            break;
 
        case FP3 :
            fp3_elt_add_fp_elt((fp3_elt_ptr)dst, (fp3_elt_srcptr)src1, (fp_elt_srcptr)(*src2), k->param);
            break;
    }
}
 
static inline void
field_elt_dec (fe_ptr dst, fe_srcptr src, field_srcptr k)
{
    switch(k->type)
    {
        case FP :
            fp_elt_dec((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src), k->param);
            break;
        
        case FP2 :
            fp2_elt_dec((fp2_elt_ptr)dst, (fp2_elt_srcptr)src, k->param);
            break;
 
        case FP3 :
            fp3_elt_dec((fp3_elt_ptr)dst, (fp3_elt_srcptr)src, k->param);
            break;
    }
}
 
static inline void
field_elt_sub (fe_ptr dst, fe_srcptr src1, fe_srcptr src2, field_srcptr k)
{
    switch(k->type)
    {
        case FP :
            fp_elt_sub((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src1), (fp_elt_srcptr)(*src2), k->param);
            break;
 
        case FP2 :
            fp2_elt_sub((fp2_elt_ptr)dst, (fp2_elt_srcptr)src1, (fp2_elt_srcptr)src2, k->param);
            break;
 
        case FP3 :
            fp3_elt_sub((fp3_elt_ptr)dst, (fp3_elt_srcptr)src1, (fp3_elt_srcptr)src2, k->param);
            break;
    }
}
 
static inline void
field_elt_sub_fp_elt (fe_ptr dst, fe_srcptr src1, fe_srcptr src2, field_srcptr k)
{
    switch(k->type)
    {
        case FP :
            fp_elt_sub((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src1), (fp_elt_srcptr)(*src2), k->param);
            break;
 
        case FP2 :
            fp2_elt_sub_fp_elt((fp2_elt_ptr)dst, (fp2_elt_srcptr)src1, (fp_elt_srcptr)(*src2), k->param);
            break;
 
        case FP3 :
            fp3_elt_sub_fp_elt((fp3_elt_ptr)dst, (fp3_elt_srcptr)src1, (fp_elt_srcptr)(*src2), k->param);
            break;
    }
}
 
static inline void
field_elt_neg (fe_ptr dst, fe_srcptr src, field_srcptr k)
{
    switch(k->type)
    {
        case FP :
            fp_elt_neg((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src), k->param);
            break;
 
        case FP2 :
            fp2_elt_neg((fp2_elt_ptr)dst, (fp2_elt_srcptr)src, k->param);
            break;
 
        case FP3 :
            fp3_elt_neg((fp3_elt_ptr)dst, (fp3_elt_srcptr)src, k->param);
            break;
    }
}
 
static inline void
field_elt_neg_fp_elt (fe_ptr dst, fe_srcptr src, field_srcptr k)
{
    switch(k->type)
    {
        case FP :
            fp_elt_neg((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src), k->param);
            break;
 
        case FP2 :
            fp2_elt_neg_fp_elt((fp2_elt_ptr)dst, (fp_elt_srcptr)(*src), k->param);
            break;
 
        case FP3 :
            fp3_elt_neg_fp_elt((fp3_elt_ptr)dst, (fp_elt_srcptr)(*src), k->param);
            break;
    }
}
 
 
 
/*******************************MULTIPLICATION********************************/
 
static inline void
field_elt_mul (fe_ptr dst, fe_srcptr src1, fe_srcptr src2, field_srcptr k, uint8_t stack)
{
    switch(k->type)
    {
        case FP :
            fp_elt_mul((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src1), (fp_elt_srcptr)(*src2), k->param, stack);
            break;
 
        case FP2 :
            fp2_elt_mul((fp2_elt_ptr)dst, (fp2_elt_srcptr)src1, (fp2_elt_srcptr)src2, k->param, stack);
            break;
 
        case FP3 :
            fp3_elt_mul((fp3_elt_ptr)dst, (fp3_elt_srcptr)src1, (fp3_elt_srcptr)src2, k->param, stack);
            break;
    }
}
 
static inline void
field_elt_mul_fp_elt (fe_ptr dst, fe_srcptr src1, fe_srcptr src2, field_srcptr k, uint8_t stack)
{
    switch(k->type)
    {
        case FP :
            fp_elt_mul((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src1), (fp_elt_srcptr)(*src2), k->param, stack);
            break;
 
        case FP2 :
            fp2_elt_mul_fp_elt((fp2_elt_ptr)dst, (fp2_elt_srcptr)src1, (fp_elt_srcptr)(*src2), k->param, stack);
            break;
 
        case FP3 :
            fp3_elt_mul_fp_elt((fp3_elt_ptr)dst, (fp3_elt_srcptr)src1, (fp_elt_srcptr)(*src2), k->param, stack);
            break;
    }
}
 
static inline void
field_elt_mul2 (fe_ptr dst, fe_srcptr src, field_srcptr k)
{
    switch(k->type)
    {
        case FP :
            fp_elt_mul2((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src), k->param);
            break;
 
        case FP2 :
            fp2_elt_mul2((fp2_elt_ptr)dst, (fp2_elt_srcptr)src, k->param);
            break;
 
        case FP3 :
            fp3_elt_mul2((fp3_elt_ptr)dst, (fp3_elt_srcptr)src, k->param);
            break;
    }
}
 
static inline void
field_elt_mul4 (fe_ptr dst, fe_srcptr src, field_srcptr k)
{
    switch(k->type)
    {
        case FP :
            fp_elt_mul4((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src), k->param);
            break;
 
        case FP2 :
            fp2_elt_mul4((fp2_elt_ptr)dst, (fp2_elt_srcptr)src, k->param);
            break;
 
        case FP3 :
            fp3_elt_mul4((fp3_elt_ptr)dst, (fp3_elt_srcptr)src, k->param);
            break;
    }
}
 
static inline void
field_elt_mul8 (fe_ptr dst, fe_srcptr src, field_srcptr k)
{
    switch(k->type)
    {
        case FP :
            fp_elt_mul8((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src), k->param);
            break;
 
        case FP2 :
            fp2_elt_mul8((fp2_elt_ptr)dst, (fp2_elt_srcptr)src, k->param);
            break;
 
        case FP3 :
            fp3_elt_mul8((fp3_elt_ptr)dst, (fp3_elt_srcptr)src, k->param);
            break;
    }
}
 
static inline void
field_elt_mul3 (fe_ptr dst, fe_srcptr src, field_srcptr k, uint8_t stack)
{
    switch(k->type)
    {
        case FP :
            fp_elt_mul3((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src), k->param, stack);
            break;
 
        case FP2 :
            fp2_elt_mul3((fp2_elt_ptr)dst, (fp2_elt_srcptr)src, k->param, stack);
            break;
 
        case FP3 :
            fp3_elt_mul3((fp3_elt_ptr)dst, (fp3_elt_srcptr)src, k->param, stack);
            break;
    }
}
 
static inline void
field_elt_sqr (fe_ptr dst, fe_srcptr src, field_srcptr k, uint8_t stack)
{
    switch(k->type)
    {
        case FP :
            fp_elt_sqr((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src), k->param, stack);
            break;
 
        case FP2 :
            fp2_elt_sqr((fp2_elt_ptr)dst, (fp2_elt_srcptr)src, k->param, stack);
            break;
 
        case FP3 :
            fp3_elt_sqr((fp3_elt_ptr)dst, (fp3_elt_srcptr)src, k->param, stack);
            break;
    }
}
 
static inline void
field_elt_sqr_fp_elt (fe_ptr dst, fe_srcptr src, field_srcptr k, uint8_t stack)
{
    switch(k->type)
    {
        case FP :
            fp_elt_sqr((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src), k->param, stack);
            break;
 
        case FP2 :
            fp2_elt_sqr_fp_elt((fp2_elt_ptr)dst, (fp_elt_srcptr)(*src), k->param, stack);
            break;
 
        case FP3 :
            fp3_elt_sqr_fp_elt((fp3_elt_ptr)dst, (fp_elt_srcptr)(*src), k->param, stack);
            break;
    }
}
 
void
field_elt_pow_ui (fe_ptr dst, fe_srcptr src, const block n, field_srcptr k, uint8_t stack);
 
void
field_elt_pow_number (fe_ptr dst, fe_srcptr src, number_srcptr n, field_srcptr k, uint8_t stack);
 
bool
field_elt_issquare (fe_srcptr src, field_srcptr k, uint8_t stack);
 
int8_t
field_elt_ispower_ui (fe_srcptr src, const block n, field_srcptr k, uint8_t stack);
 
int8_t
field_elt_ispower_number (fe_srcptr src, number_srcptr n, field_srcptr k, uint8_t stack);
 
void 
field_find_nonsquare (fe_ptr dst, field_ptr k, uint8_t stack);
 
bool
field_find_nonpower_ui (fe_ptr dst, const block n, field_ptr k, uint8_t stack);
 
bool
field_find_nonpower_number (fe_ptr dst, number_srcptr n, field_ptr k, uint8_t stack);
 
void
field_elt_sqrt (fe_ptr dst, fe_srcptr src, field_srcptr k, uint8_t stack);
 
void
field_elt_cube_root (fe_ptr dst, fe_srcptr src, field_srcptr k, uint8_t stack);
 
void
field_elt_unity_nth_root (fe_ptr dst, const block n, field_ptr k, uint8_t stack);
 
/**********************************DIVISION***********************************/
 
void
field_elt_inv (fe_ptr dst, fe_srcptr src, field_srcptr k, uint8_t stack);
 
void
field_elt_inv_fp_elt (fe_ptr dst, fe_srcptr src, field_srcptr k, uint8_t stack);
 
void
field_elt_div (fe_ptr dst, fe_srcptr src1, fe_srcptr src2, field_srcptr k, uint8_t stack);
 
void
field_elt_div_fp_elt (fe_ptr dst, fe_srcptr src1, fe_srcptr src2, field_srcptr k, uint8_t stack);
 
#endif