mphell-amns.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_AMNS_H
#define MPHELL_AMNS_H
 
#include "mphell-number.h"
 
/**************************************DATA STRUCTURE**********************************/
 
#if MPHELL_USE_AMNS_32 == 0
#define AMNS_WORD_SIZE 64
typedef int64_t amns_block;
typedef uint64_t amns_ulong;
typedef __int128 amns_llong;
typedef unsigned __int128 amns_ullong;
typedef __float128 amns_ldouble;
typedef double amns_double;
 
#else
 
#define AMNS_WORD_SIZE 32
typedef int32_t amns_block;
typedef uint32_t amns_ulong;
typedef int64_t amns_llong;
typedef uint64_t amns_ullong;
typedef double amns_ldouble;
typedef double amns_double;
#endif
 
typedef amns_block * amns_elt;
 
typedef amns_block * amns_elt_ptr;
 
typedef const amns_block * amns_elt_srcptr;
 
 
struct amns 
{
    number p;                         
    uint16_t p_size;                  
    amns_elt E;                       
    uint8_t k;                        
    number gamma;                     
    uint16_t gamma_size;              
    uint8_t n;                        
    uint8_t rho;                      
    amns_block max_digit;             
    amns_block min_digit;             
    amns_block max_digit_delta;       
    amns_block min_digit_delta;       
    uint8_t amns_block_size;          
    amns_llong max_amns_block;        
    amns_block lambda;                
    uint8_t lambda_bit;               
    bool lambda_sign;                 
    uint8_t nb_add_max;               
    amns_elt * Mti;                   
    amns_elt * Mtiprime;              
    amns_elt * Ti;                    
    number * gi;                      
    amns_elt pool_1[POOL_SIZE_AMNS];  
    uint8_t i_1;                      
#if MPHELL_USE_MULTITHREADING == 1 
    amns_elt pool_2[POOL_SIZE_AMNS];  
    uint8_t i_2;                      
#endif
    
    void (*amns_elt_mul)(amns_elt_ptr, amns_elt_srcptr, amns_elt_srcptr, const struct amns *);
    void (*amns_elt_sqr)(amns_elt_ptr, amns_elt_srcptr, const struct amns *);
    void (*amns_elt_add)(amns_elt_ptr, amns_elt_srcptr, amns_elt_srcptr, const struct amns *);
    void (*amns_elt_sub)(amns_elt_ptr, amns_elt_srcptr, amns_elt_srcptr, const struct amns *);
    void (*amns_elt_neg)(amns_elt_ptr, amns_elt_srcptr, const struct amns *);
    void (*amns_internal_red)(amns_elt_ptr, amns_llong *, const struct amns *);
    bool (*amns_elt_is_reduced)(amns_elt_srcptr, const struct amns *);
 
#if MPHELL_USE_DEBUG == 1
    int nb_add;
    int nb_sub;
    int nb_mul;
    int nb_add_red;
    int nb_sub_red;
    int nb_mul_red;
#endif
};  
 
typedef struct amns amns_t;
 
typedef amns_t * amns;
 
typedef amns_t * amns_ptr;
 
typedef const amns_t * amns_srcptr;
 
 
/**************************************TMP**************************************/
 
static inline void
amns_elt_get_pool_elt (amns_elt * dst, amns_srcptr AMNS, uint8_t stack)
{
#if MPHELL_USE_MULTITHREADING == 0
    MPHELL_ASSERT(stack == STACK_1, "amns_elt_get_pool_elt, unknow stack \n");
    MPHELL_ASSERT(AMNS->i_1 < POOL_SIZE_AMNS, "amns_elt_get_pool_elt, stack is too small \n");
    *dst = (AMNS->pool_1)[(((amns_ptr)AMNS)->i_1)++];
#elif MPHELL_USE_MULTITHREADING == 1
    if(stack == STACK_1)
    {
        MPHELL_ASSERT(AMNS->i_1 < POOL_SIZE_AMNS, "amns_elt_get_pool_elt, stack is too small \n");
        *dst = (AMNS->pool_1)[(((amns_ptr)AMNS)->i_1)++];
    }
    else if (stack == STACK_2)
    {
        MPHELL_ASSERT(AMNS->i_2 < POOL_SIZE_AMNS, "amns_elt_get_pool_elt, stack is too small \n");
        *dst = (AMNS->pool_2)[(((amns_ptr)AMNS)->i_2)++];
    }
    else
    {
        *dst = 0;
        mphell_error("amns_elt_get_pool_elt, unknow stack \n");
    }
#endif
}
 
static inline void
amns_elt_relax_pool_elt (amns_elt * dst, amns_srcptr AMNS, uint8_t stack)
{
#if MPHELL_USE_MULTITHREADING == 0
    MPHELL_ASSERT(stack == STACK_1, "amns_elt_relax_pool_elt, unknow stack \n");
    (((amns_ptr)AMNS)->i_1)--;
    MPHELL_ASSERT(AMNS->i_1 >= 0, "AMNS->i_1 is < 0 in pool 1\n");
#elif MPHELL_USE_MULTITHREADING == 1
    if(stack == STACK_1)
    {
        (((amns_ptr)AMNS)->i_1)--;
        MPHELL_ASSERT(AMNS->i_1 >= 0, "AMNS->i_1 is < 0 in pool 1\n");
    }
    else if (stack == STACK_2)
    {
        (((amns_ptr)AMNS)->i_2)--;
        MPHELL_ASSERT(AMNS->i_2 >= 0, "AMNS->i_2 is < 0 in pool 2\n");
    }
    else
    {
        mphell_error("amns_elt_relax_pool_elt, unknow stack \n");
    }
#endif
}
 
/**************************************ALLOCATION**************************************/
 
void amns_alloc(amns_ptr * AMNS, uint8_t n, number_srcptr p);
 
void amns_free(amns_ptr * AMNS);
 
void amns_elt_alloc(amns_elt * dst, amns_srcptr AMNS);
 
void amns_elt_free(amns_elt * dst);
 
 
/*****************************************PRINT****************************************/
 
void amns_print_bloc(amns_block b);
 
void amns_print_elt_raw(const amns_block * x, uint8_t size);
 
void amns_print_elt(amns_elt_srcptr x, amns_srcptr AMNS);
 
void amns_print_AMNS(amns_srcptr AMNS);
 
void amns_print_stat(amns_srcptr AMNS);
 
/***************************************HELPER*****************************************/
 
uint8_t amns_calculate_rho(amns_srcptr AMNS);
 
 
/************************************INITIALISATION************************************/
 
void amns_alloc_init_str(amns_ptr * AMNS, char * str, number p);
 
void amns_init(amns_ptr AMNS, const amns_block * E, const amns_block * P0, const amns_block *P1, const amns_block *M, const amns_ulong *Mprime,  number_srcptr p, number gamma, uint8_t rho, uint8_t nb_add_max);
 
void set_fast_internal_reduction_nist521(amns_ptr AMNS);
 
void amns_init_stat(amns_ptr AMNS);
 
 
/******************************************IO******************************************/
 
void amns_elt_write(amns_block * x, uint8_t size, char * str);
 
void amns_elt_read(amns_block * x, char * str);
 
void amns_elt_read_ul(amns_ulong * x, char * str);
 
void amns_elt_set_zero(amns_elt_ptr dst, amns_srcptr AMNS);
 
 
/**************************************CONVERSION**************************************/
 
void binary_to_amns(number_srcptr a, amns_elt_ptr dst, amns_srcptr AMNS);
 
void binary_ui_to_amns(block a, amns_elt_ptr dst, amns_srcptr AMNS);
 
void amns_to_binary(const amns_elt_srcptr a, number_ptr dst, amns_srcptr AMNS);
 
 
/***************************************COMPARISON**************************************/
 
bool amns_elt_is_zero(amns_elt_srcptr src, amns_srcptr AMNS);
 
bool amns_elt_isequal(amns_elt_srcptr src1, amns_elt_srcptr src2, amns_srcptr AMNS);
 
int8_t amns_elt_cmp(amns_elt_srcptr src1, amns_elt_srcptr src2, amns_srcptr AMNS);
 
int8_t amns_elt_cmp_ui(amns_elt_srcptr src1, block scr2, amns_srcptr AMNS);
 
 
/***************************************ARITHMETIC**************************************/
 
void amns_elt_copy(amns_elt_ptr dst, amns_elt_srcptr a, amns_srcptr AMNS);
 
void amns_elt_add(amns_elt_ptr dst, amns_elt_srcptr a, amns_elt_srcptr b, amns_srcptr AMNS);
 
void amns_elt_neg(amns_elt_ptr dst, amns_elt_srcptr a, amns_srcptr AMNS);
 
void amns_elt_sub(amns_elt_ptr dst, amns_elt_srcptr a, amns_elt_srcptr b, amns_srcptr AMNS);
 
void amns_elt_mul(amns_elt_ptr dst, amns_elt_srcptr a, amns_elt_srcptr b, amns_srcptr AMNS);
 
void amns_elt_sqr(amns_elt_ptr dst, amns_elt_srcptr a, amns_srcptr AMNS);
 
 
#endif