mphell-field.c

Go to the documentation of this file.

/* 
  MPHELL-4.0 
  Author(s): The MPHELL team

 (C) Copyright 2015-2018 - 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/>.
*/

#include "mphell-field.h"

/**************************************TMP**********************************/

/* void field_elt_get_pool_elt (field_elt * dst, field_ptr k, uint8_t stack){} is inline */

/* void field_elt_relax_pool_elt (field_elt * dst, field_ptr k, uint8_t stack){} is inline */

/************************************SETTERS**********************************/

void
field_alloc (field_ptr k, const field_type type, const uint8_t size, field_ptr base)
{
    switch(type)
    {
        case FP :
            k->param = (fp_param_t *)malloc(sizeof(fp_param_t));
            fp_alloc(k->param, size);
            break;

        case FP2 :
            k->param = (fp2_param_t *)malloc(sizeof(fp2_param_t));
            fp2_alloc(k->param, (fp_param)(base->param));
            break;

        case FP3 :
            k->param = (fp3_param_t *)malloc(sizeof(fp3_param_t));
            fp3_alloc(k->param, (fp_param)(base->param));
            break;
    }
    k->type = type;
    k->size = size;
    
    /* Pools creation */
    uint8_t i;
    k->i_1 = 0;
    for(i=0; i<POOL_SIZE_FIELD; i++)
    {
        field_elt_alloc(&(k->pool_1)[i], k);
    }
#if MPHELL_USE_MULTITHREADING == 1
    k->i_2 = 0;
    for(i=0; i<POOL_SIZE_FIELD; i++)
    {
        field_elt_alloc(&(k->pool_2)[i], k);
    }
#endif
}

void
field_create (field_ptr k, const char* id, uint8_t stack, const uint32_t n, ...)
{
    va_list va;
    field_t * base;
    number_t * p;
    fp_elt * non_residue;
    fp_id ID;
    
    if((id != NULL) && (id[0] != '\0'))
    {
        strcpy(k->id, id);
        if(strcmp(id, "p192r1")==0)
        {
            ID = P192R1;
        }
        else if(strcmp(id, "p224r1")==0)
        {
            ID = P224R1;
        }
        else if(strcmp(id, "p256r1")==0)
        {
            ID = P256R1;
        }
        else if(strcmp(id, "p384r1")==0)
        {
            ID = P384R1;
        }
        else if(strcmp(id, "p521r1")==0)
        {
            ID = P521R1;
        }
        else
        {
            ID = ARBITRARY;
        }
    }
    else
    {
        strcpy(k->id, "NO_ID");
        ID = ARBITRARY;
    }
    
    switch(k->type)
    {
        case FP :
            va_start(va, n);
            p = va_arg(va, number_t *);
            fp_create(k->param, p, ID, stack);
            k->bit_size = number_log2(p);
            va_end(va);
            break;

        case FP2 :
            va_start(va, n);
            base = va_arg(va, field_t *);
            non_residue = va_arg(va, fp_elt *);
            fp2_create(k->param, base->param, *non_residue, stack);
            va_end(va);
            k->bit_size = base->bit_size;
            break;

        case FP3 :
            va_start(va, n);
            base = va_arg(va, field_t *);
            non_residue = va_arg(va, fp_elt *);
            fp3_create(k->param, base->param, *non_residue, stack);
            k->bit_size = base->bit_size;
            va_end(va);
            break;
    }
    
    /* Pools creation */
    uint8_t i;
    k->i_1 = 0;
    for(i=0; i<POOL_SIZE_FIELD; i++)
    {
        field_elt_init((k->pool_1)[i], k);
    }
#if MPHELL_USE_MULTITHREADING == 1
    k->i_2 = 0;
    for(i=0; i<POOL_SIZE_FIELD; i++)
    {
        field_elt_init((k->pool_2)[i], k);
    }
#endif
}

void
field_copy (field_ptr k_res, field_srcptr k)
{
    switch(k->type)
    {
        case FP :
            fp_copy(k_res->param, k->param);
            break;

        case FP2 :
            fp2_copy(k_res->param, k->param);
            break;

        case FP3 :
            fp3_copy(k_res->param, k->param);
            break;
    }
}

void
field_free (field_ptr k)
{
    switch(k->type)
    {
        case FP :
            fp_free(k->param);
            break;

        case FP2 :
            fp2_free(k->param);
            break;

        case FP3 :
            fp3_free(k->param);
            break;
    }
    k->size = 0;
    free(k->param);
    k->param = NULL;
    
    /* Pools free */
    uint8_t i;
    k->i_1 = 0;
    for(i=0; i<POOL_SIZE_FIELD; i++)
    {
        field_elt_free(&(k->pool_1)[i], k);
    }
#if MPHELL_USE_MULTITHREADING == 1
    k->i_2 = 0;
    for(i=0; i<POOL_SIZE_FIELD; i++)
    {
        field_elt_free(&(k->pool_2)[i], k);
    }
#endif
}

void
field_get_size (number_ptr c, field_srcptr k)
{
    switch(k->type)
    {
        case FP :
            fp_get_characteristic(c, k->param);
            break;

        case FP2 :
            fp2_get_size(c, k->param);
            break;

        case FP3 :
            fp3_get_size(c, k->param);
            break;
    }
}

void
field_get_characteristic (number_ptr c, field_srcptr k)
{
    switch(k->type)
    {
        case FP :
            fp_get_characteristic(c, k->param);
            break;

        case FP2 :
            fp2_get_characteristic(c, k->param);
            break;

        case FP3 :
            fp3_get_characteristic(c, k->param);
            break;
    }
}

/*void*/
/*field_get_pm2(char* str, field_srcptr k)*/
/*{*/
/*    switch(k->type)*/
/*    {*/
/*        case FP :*/
/*            fp_get_pm2(str, k->param);*/
/*            break;*/

/*        case FP2 :*/
/*            fp2_get_pm2(str, k->param);*/
/*            break;*/

/*        case FP3 :*/
/*            fp3_get_pm2(str, k->param);*/
/*            break;*/
/*    }*/
/*}*/

void
field_elt_alloc (fe_ptr *dst, field_srcptr k)
{
    switch(k->type)
    {
        case FP :
            *dst = (fp_elt *)malloc(sizeof(fp_elt));
            fp_elt_alloc((fp_elt *)(*dst), k->param);
            break;

        case FP2 :
            *dst = (fp_elt *)malloc(sizeof(fp2_elt));
            fp2_elt_alloc((fp2_elt *)(*dst), k->param);
            break;

        case FP3 :
            *dst = (fp_elt *)malloc(sizeof(fp3_elt));
            fp3_elt_alloc((fp3_elt *)(*dst), k->param);
            break;
    }
}

void
field_elt_init (fe_ptr dst, field_srcptr k)
{
    switch(k->type)
    {
        case FP :          
            fp_elt_init((fp_elt_ptr)(*dst), k->param);
            break;

        case FP2 :
            fp2_elt_init((fp2_elt_ptr)dst, k->param);
            break;

        case FP3 :
            fp3_elt_init((fp3_elt_ptr)dst, k->param);
            break;
    }
}

void
field_elt_copy (fe_ptr dst, fe_srcptr src, field_srcptr k)
{
    switch(k->type)
    {
        case FP :
            fp_elt_copy((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src), k->param);
            break;

        case FP2 :
            fp2_elt_copy((fp2_elt_ptr)dst, (fp2_elt_srcptr)src, k->param);
            break;

        case FP3 :
            fp3_elt_copy((fp3_elt_ptr)dst, (fp3_elt_srcptr)src, k->param);
            break;
    }
}

void
field_elt_clear (fe_ptr *src, field_srcptr k)
{
    switch(k->type)
    {
        case FP :
            fp_elt_clear((fp_elt *)(*src));
            break;

        case FP2 :
            fp2_elt_clear((fp2_elt *)(*src));
            break;

        case FP3 :
            fp3_elt_clear((fp3_elt *)(*src));
            break;
    }
}

void
field_elt_free (fe_ptr *src, field_srcptr k)
{
    switch(k->type)
    {
        case FP :
            fp_elt_free((fp_elt *)(*src));
            break;

        case FP2 :
            fp2_elt_free((fp2_elt *)(*src));
            break;

        case FP3 :
            fp3_elt_free((fp3_elt *)(*src));
            break;
    }
    free(*src);
}

void
field_elt_set_one (fe_ptr dst, field_srcptr k)
{
    switch(k->type)
    {
        case FP :
            fp_elt_set_one((fp_elt_ptr)(*dst), k->param);
            break;
        
        case FP2 :
            fp2_elt_set_one((fp2_elt_ptr)dst, k->param);
            break;

        case FP3 :
            fp3_elt_set_one((fp3_elt_ptr)dst, k->param);
            break;
    }
}

void
field_elt_set_ui (fe_ptr dst, const block src, const bool isreduced, 
        field_srcptr k, uint8_t stack)
{
    switch(k->type)
    {
        case FP :
            fp_elt_set_ui((fp_elt_ptr)(*dst), src, isreduced, k->param, stack);
            break;

        case FP2 :
            fp2_elt_set_ui((fp2_elt_ptr)dst, src, isreduced, k->param, stack);
            break;

        case FP3 :
            fp3_elt_set_ui((fp3_elt_ptr)dst, src, isreduced, k->param, stack);
            break;
    }
}

void
field_elt_set_number (fe_ptr dst, const bool isreduced, field_srcptr k, uint8_t stack, const uint32_t n, ...)
{
    va_list va;
    va_start(va, n);
    number_t *n1, *n2, *n3;
    switch(k->type)
    {
        case FP :
            n1 = va_arg(va, number_t *);
            fp_elt_set_number((fp_elt_ptr)(*dst), n1, isreduced, k->param, stack);
            break;

        case FP2 :
            if(n == 1)
            {
                n1 = va_arg(va, number_t *);
                fp2_elt_set_number((fp2_elt_ptr)dst, n1, isreduced, k->param, stack);
            }
            else
            {
                n1 = va_arg(va, number_t *);
                n2 = va_arg(va, number_t *);
                fp2_elt_set((fp2_elt_ptr)dst, n1, n2, isreduced, k->param, stack);
            }
            break;

        case FP3 :
            if(n == 1)
            {
                n1 = va_arg(va, number_t *);
                fp3_elt_set_number((fp3_elt_ptr)dst, n1, isreduced, k->param, stack);
            }
            else
            {
                n1 = va_arg(va, number_t *);
                n2 = va_arg(va, number_t *);
                n3 = va_arg(va, number_t *);
                fp3_elt_set((fp3_elt_ptr)dst, n1, n2, n3, isreduced, k->param, stack);
            }
            break;
    }
    va_end(va);
}

void
field_elt_set_fp_elts (fe_ptr dst, field_srcptr k, const uint32_t n, ...)
{
    va_list va;
    va_start(va, n);
    fp_elt *n1, *n2, *n3;
    switch(k->type)
    {
        case FP :
            n1 = va_arg(va, fp_elt *);
            fp_elt_copy((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*n1), k->param);
            break;

        case FP2 :
            if(n == 1)
            {
                n1 = va_arg(va, fp_elt *);
                fp2_elt_set_fp_elt((fp2_elt_ptr)dst, (fp_elt_srcptr)(*n1), k->param);
            }
            else
            {
                n1 = va_arg(va, fp_elt *);
                n2 = va_arg(va, fp_elt *);
                fp2_elt_set_fp_elts((fp2_elt_ptr)dst, (fp_elt_srcptr)(*n1), (fp_elt_srcptr)(*n2), k->param);
            }
            break;

        case FP3 :
            if(n == 1)
            {
                n1 = va_arg(va, fp_elt *);
                fp3_elt_set_fp_elt((fp3_elt_ptr)dst, (fp_elt_srcptr)(*n1), k->param);
            }
            else
            {
                n1 = va_arg(va, fp_elt *);
                n2 = va_arg(va, fp_elt *);
                n3 = va_arg(va, fp_elt *);
                fp3_elt_set_fp_elts((fp3_elt_ptr)dst, (fp_elt_srcptr)(*n1), (fp_elt_srcptr)(*n2), (fp_elt_srcptr)(*n3), k->param);
            }
            break;
    }
    va_end(va);
}

void
field_elt_set_str (fe_ptr dst, const char *str, const uint8_t base, 
        const bool isreduced, field_srcptr k, uint8_t stack)
{
    switch(k->type)
    {
        case FP :
            fp_elt_set_str((fp_elt_ptr)(*dst), str, base, isreduced, k->param, stack);
            break;

        case FP2 :
            fp2_elt_set_str((fp2_elt_ptr)dst, str, base, isreduced, k->param, stack);
            break;

        case FP3 :
            fp3_elt_set_str((fp3_elt_ptr)dst, str, base, isreduced, k->param, stack);
            break;
    }
}

void
field_elt_random (fe_ptr dst, field_srcptr k, uint8_t stack)
{
    switch(k->type)
    {
        case FP :
            fp_elt_random((fp_elt_ptr)(*dst), k->param, stack);
            break;

        case FP2 :
            fp2_elt_random((fp2_elt_ptr)dst, k->param, stack);
            break;

        case FP3 :
            fp3_elt_random((fp3_elt_ptr)dst, k->param, stack);
            break;
    }
}

void
field_elt_lift (fe_ptr dst, fe_srcptr src, field_srcptr k, uint8_t stack)
{
    switch(k->type)
    {
        case FP :
            fp_elt_lift((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src), k->param, stack);
            break;

        case FP2 :
            fp2_elt_lift((fp2_elt_ptr)dst, (fp2_elt_srcptr)src, k->param, stack);
            break;

        case FP3 :
            fp3_elt_lift((fp3_elt_ptr)dst, (fp3_elt_srcptr)src, k->param, stack);
            break;
    }
}

void
field_elt_get_number (number_ptr dst, fe_srcptr src, uint8_t pos, field_srcptr k, uint8_t stack)
{
    switch(k->type)
    {
        case FP :
            fp_elt_get_number(dst, (fp_elt_srcptr)(*src), k->param, stack);
            break;

        case FP2 :
            if(pos == 1)
            {
                fp_elt_get_number(dst, ((fp2_elt *)src)->v0, ((fp2_param_t *)(k->param))->base, stack);
            }
            else if (pos == 2)
            {
                fp_elt_get_number(dst, ((fp2_elt *)src)->v1, ((fp2_param_t *)(k->param))->base, stack);
            }
            else
            {
                mphell_error("pos must be 1 or 2 to get first or second part of the FP2 element\n");
            }
            break;
        case FP3 :
            if(pos == 1)
            {
                fp_elt_get_number(dst, ((fp3_elt *)src)->v0, ((fp3_param_t *)(k->param))->base, stack);
            }
            else if (pos == 2)
            {
                fp_elt_get_number(dst, ((fp3_elt *)src)->v1, ((fp3_param_t *)(k->param))->base, stack);
            }
            else if (pos == 3)
            {
                fp_elt_get_number(dst, ((fp3_elt *)src)->v2, ((fp3_param_t *)(k->param))->base, stack);
            }
            else
            {
                mphell_error("pos must be 1, 2 or 3 to get first, second or third  part of the FP3 element\n");
            }
            break;
    }
}

void
field_elt_get_fp_elt (fe_ptr dst, fe_srcptr src, uint8_t pos, field_srcptr k)
{
    switch(k->type)
    {
        case FP :
            fp_elt_copy((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src), k->param);
            break;

        case FP2 :
            if(pos == 1)
            {
                fp_elt_copy((fp_elt_ptr)(*dst), ((fp2_elt *)src)->v0, ((fp2_param_t *)(k->param))->base);
            }
            else if (pos == 2)
            {
                fp_elt_copy((fp_elt_ptr)(*dst), ((fp2_elt *)src)->v1, ((fp2_param_t *)(k->param))->base);
            }
            else
            {
                mphell_error("pos must be 1 or 2 to get first or second part of the FP2 element\n");
            }
            break;
        case FP3 :
            if(pos == 1)
            {
                fp_elt_copy((fp_elt_ptr)(*dst), ((fp3_elt *)src)->v0, ((fp3_param_t *)(k->param))->base);
            }
            else if (pos == 2)
            {
                fp_elt_copy((fp_elt_ptr)(*dst), ((fp3_elt *)src)->v1, ((fp3_param_t *)(k->param))->base);
            }
            else if (pos == 3)
            {
                fp_elt_copy((fp_elt_ptr)(*dst), ((fp3_elt *)src)->v2, ((fp3_param_t *)(k->param))->base);
            }
            else
            {
                mphell_error("pos must be 1, 2 or 3 to get first, second or third  part of the FP3 element\n");
            }
            break;
    }
}

void
field_str (char **str, field_srcptr k, const uint8_t base, uint8_t stack)
{
    char *def, *param_str = NULL;
    switch(k->type)
    {
        case FP :
            def = "Prime field :\n";
            fp_str(&param_str, k->param, base, stack);
            break;
        case FP2 :
            def = "Quadractic extension of prime field :\n";
            fp2_str(&param_str, k->param, base, stack);
            break;
        case FP3 :
            def = "Cubic extension of prime field :\n";
            fp3_str(&param_str, k->param, base, stack);
            break;
    }
    if(param_str != NULL)
    {
        *str = (char*)malloc(strlen(def) + strlen(param_str) + 2);
        sprintf(*str, "%s%s", def, param_str);
        free(param_str);
    }
    else
    {
        *str = NULL;
    }
}

void
field_print (field_srcptr k, const uint8_t base, uint8_t stack)
{
    char *str;
    field_str(&str, k, base, stack);
    printf("%s\n", str);
    free(str);
}

void
field_elt_str (char **str, fe_srcptr src, const uint8_t base, const bool lift, field_srcptr k, uint8_t stack)
{
    char *v_str = NULL;
    switch(k->type)
    {
        case FP :
            fp_elt_str(&v_str, (fp_elt_ptr)(*src), base, lift, k->param, stack);
            break;

        case FP2 :
            fp2_elt_str(&v_str, (fp2_elt_ptr)src, base, lift, k->param, stack);
            break;

        case FP3 :
            fp3_elt_str(&v_str, (fp3_elt_ptr)src, base, lift, k->param, stack);
            break;
    }
    if(v_str != NULL)
    {
        *str = (char*)malloc(strlen(v_str)+1);
        strcpy(*str, v_str);
        free(v_str);
    }
    else
    {
        *str = NULL;
    }
}

void
field_elt_print (fe_srcptr src, const uint8_t base, const bool lift, field_srcptr k, uint8_t stack)
{
    char *str;
    field_elt_str(&str, src, base, lift, k, stack);
    printf("%s", str);
    free(str);
}

/*************************COMPARISON AND LOGICAL******************************/

int8_t
field_elt_cmp (fe_srcptr src1, fe_srcptr src2, field_srcptr k)
{
    int8_t res = -1;
    switch(k->type)
    {
        case FP :
            res = fp_elt_cmp((fp_elt_srcptr)(*src1), (fp_elt_srcptr)(*src2), k->param);
            break;

        case FP2 :
            res = fp2_elt_cmp((fp2_elt_srcptr)src1, (fp2_elt_srcptr)src2, k->param);
            break;

        case FP3 :
            res = fp3_elt_cmp((fp3_elt_srcptr)src1, (fp3_elt_srcptr)src2, k->param);
            break;
    }
    return res;
}

int8_t
field_elt_cmp_fp_elt (fe_srcptr src1, fe_srcptr src2, field_srcptr k)
{
    int8_t res = -1;
    switch(k->type)
    {
        case FP :
            res = fp_elt_cmp((fp_elt_srcptr)(*src1), (fp_elt_srcptr)(*src2), k->param);
            break;

        case FP2 :
            res = fp2_elt_cmp_fp_elt((fp2_elt_srcptr)src1, (fp_elt_srcptr)(*src2), k->param);
            break;

        case FP3 :
            res = fp3_elt_cmp_fp_elt((fp3_elt_srcptr)src1, (fp_elt_srcptr)(*src2), k->param);
            break;
    }
    return res;
}

bool
field_elt_isone (fe_srcptr src, field_srcptr k)
{
    bool res = false;
    switch(k->type)
    {
        case FP :
            res = fp_elt_isone((fp_elt_srcptr)(*src), k->param);
            break;

        case FP2 :
            res = fp2_elt_isone((fp2_elt_srcptr)src, k->param);
            break;

        case FP3 :
            res = fp3_elt_isone((fp3_elt_srcptr)src, k->param);
            break;
    }
    return res;
}

/* bool field_elt_iszero (fe_srcptr src, field_srcptr k){} is inline */

bool 
field_isequal (field_srcptr k1, field_srcptr k2)
{
    int8_t res = 0;
    int8_t res1 = 0;
    int8_t res2 = 0;
    
    if (k1->type != k2->type)
    {
        return false;
    }
    else
    {
        switch(k1->type)
        {
            case FP :
                res = number_cmp(((fp_param)k1->param)->p, ((fp_param)k2->param)->p);
                break;

            case FP2 :
                res1 = number_cmp(((fp2_param)k1->param)->q, ((fp2_param)k2->param)->q);
                res2 = fp_elt_cmp(((fp2_param)k1->param)->non_residue, ((fp2_param)k2->param)->non_residue, ((fp2_param)k1->param)->base);
                if((res1==0) && (res2 ==0))
                {
                    res = 0;
                }
                else
                {
                    res=1;
                }
                break;

            case FP3 :
                res1 = number_cmp(((fp3_param)k1->param)->q, ((fp3_param)k2->param)->q);
                res2 = fp_elt_cmp(((fp3_param)k1->param)->non_residue, ((fp3_param)k2->param)->non_residue, ((fp3_param)k1->param)->base);
                if((res1==0) && (res2 ==0))
                {
                    res = 0;
                }
                else
                {
                    res=1;
                }
                res = 0;
                break;
        }
        return (res == 0);
    }
}

/***************************ADDITION SUBTRACTION******************************/

/* void field_elt_inc (fe_ptr dst, fe_srcptr src, field_srcptr k){} is inline */

/* void field_elt_add (fe_ptr dst, fe_srcptr src1, fe_srcptr src2, field_srcptr k){} is inline */

/* void field_elt_add_fp_elt (fe_ptr dst, fe_srcptr src1, fe_srcptr src2, field_srcptr k){} is inline */

/* void field_elt_dec (fe_ptr dst, fe_srcptr src, field_srcptr k){} is inline */

/* void field_elt_sub (fe_ptr dst, fe_srcptr src1, fe_srcptr src2, field_srcptr k){} is inline */

/* void field_elt_sub_fp_elt (fe_ptr dst, fe_srcptr src1, fe_srcptr src2, field_srcptr k){} is inline */

/* void field_elt_neg (fe_ptr dst, fe_srcptr src, field_srcptr k){} is inline */

/* void field_elt_neg_fp_elt (fe_ptr dst, fe_srcptr src, field_srcptr k){} is inline */

/*******************************MULTIPLICATION********************************/

/* void field_elt_mul (fe_ptr dst, fe_srcptr src1, fe_srcptr src2, field_srcptr k, uint8_t stack){} is inline */

/* void field_elt_mul_fp_elt (fe_ptr dst, fe_srcptr src1, fe_srcptr src2, field_srcptr k, uint8_t stack){} is inline */

/* void field_elt_mul2 (fe_ptr dst, fe_srcptr src, field_srcptr k){} is inline */

/* void field_elt_mul4 (fe_ptr dst, fe_srcptr src, field_srcptr k){} is inline */

/* void field_elt_mul8 (fe_ptr dst, fe_srcptr src, field_srcptr k){} is inline */

/* void field_elt_mul3 (fe_ptr dst, fe_srcptr src, field_srcptr k, uint8_t stack){} is inline */

/* void field_elt_sqr (fe_ptr dst, fe_srcptr src, field_srcptr k, uint8_t stack){} is inline */

/* void field_elt_sqr_fp_elt (fe_ptr dst, fe_srcptr src, field_srcptr k, uint8_t stack){} is inline */

void
field_elt_pow_ui (fe_ptr dst, fe_srcptr src, const block n, field_srcptr k, uint8_t stack)
{   
    switch(k->type)
    {
        case FP :
            fp_elt_pow_ui((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src), n, k->param, stack);
            break;

        case FP2 :
            fp2_elt_pow_ui((fp2_elt_ptr)dst, (fp2_elt_srcptr)src, n, k->param, stack);
            break;

        case FP3 :
            fp3_elt_pow_ui((fp3_elt_ptr)dst, (fp3_elt_srcptr)src, n, k->param, stack);
            break;
    }
}

void
field_elt_pow_number (fe_ptr dst, fe_srcptr src, number_srcptr n, field_srcptr k, uint8_t stack)
{
    switch(k->type)
    {
        case FP :
            fp_elt_pow_number((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src), n, k->param, stack);
            break;

        case FP2 :
            fp2_elt_pow_number((fp2_elt_ptr)dst, (fp2_elt_srcptr)src, n, k->param, stack);
            break;

        case FP3 :
            fp3_elt_pow_number((fp3_elt_ptr)dst, (fp3_elt_srcptr)src, n, k->param, stack);
            break;
    }
}

bool
field_elt_issquare (fe_srcptr src, field_srcptr k, uint8_t stack)
{
    bool res = false;
    switch(k->type)
    {
        case FP :
            res = fp_elt_issquare((fp_elt_srcptr)(*src), k->param, stack);
            break;
        case FP2 :
            res = fp2_elt_issquare((fp2_elt_srcptr)src, k->param, stack);
            break;
        case FP3 :
            res = fp3_elt_issquare((fp3_elt_srcptr)src, k->param, stack);
            break;
    }
    return res;
}

int8_t
field_elt_ispower_ui (fe_srcptr src, const block n, field_srcptr k, uint8_t stack)
{
    int8_t res = 0;
    switch(k->type)
    {
        case FP :
            res = fp_elt_ispower_ui((fp_elt_srcptr)(*src), n, k->param, stack);
            break;

        case FP2 :
            res = fp2_elt_ispower_ui((fp2_elt_srcptr)src, n, k->param, stack);
            break;

        case FP3 :
            res = fp3_elt_ispower_ui((fp3_elt_srcptr)src, n, k->param, stack);
            break;
    }
    return res;
}

int8_t
field_elt_ispower_number (fe_srcptr src, number_srcptr n, field_srcptr k, uint8_t stack)
{
    int8_t res = 0;
    switch(k->type)
    {
        case FP :
            res = fp_elt_ispower_number((fp_elt_srcptr)(*src), n, k->param, stack);
            break;

        case FP2 :
            res = fp2_elt_ispower_number((fp2_elt_srcptr)src, n, k->param, stack);
            break;

        case FP3 :
            res = fp3_elt_ispower_number((fp3_elt_srcptr)src, n, k->param, stack);
            break;
    }
    return res;
}

void 
field_find_nonsquare (fe_ptr dst, field_ptr k, uint8_t stack)
{
    do 
    {
        field_elt_random(dst, k, stack);
    } while (field_elt_issquare(dst, k, stack));
}

bool
field_find_nonpower_ui (fe_ptr dst, const block n, field_ptr k, uint8_t stack)
{
    int8_t res = 0;
    do 
    {
        field_elt_random(dst, k, stack);
        res = field_elt_ispower_ui(dst, n, k, stack);
    } while (res==1);
    if(res == 2)
    {
        /* All the elements in k are some n-power */
        return false;
    }
    return true;
}

bool
field_find_nonpower_number (fe_ptr dst, number_srcptr n, field_ptr k, uint8_t stack)
{
    int8_t res = 0;
    do 
    {
        field_elt_random(dst, k, stack);
        res = field_elt_ispower_number(dst, n, k, stack);
    } while (res==1);
    if(res == 2)
    {
        /* All the elements in k are some n-power */
        return false;
    }
    return true;
}

void
field_elt_sqrt (fe_ptr dst, fe_srcptr src, field_srcptr k, uint8_t stack)
{
    MPHELL_ASSERT_ALWAYS(field_elt_issquare(src, k, stack), "field_elt_sqrt : src \
            is not a square in k");
    switch(k->type)
    {
        case FP :
            fp_elt_sqrt((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src), k->param, stack);
            break;

        case FP2 :
            fp2_elt_sqrt((fp2_elt_ptr)dst, (fp2_elt_srcptr)src, k->param, stack);
            break;

        case FP3 :
            fp3_elt_sqrt((fp3_elt_ptr)dst, (fp3_elt_srcptr)src, k->param, stack);
            break;
    }
}

void
field_elt_cube_root (fe_ptr dst, fe_srcptr src, field_srcptr k, uint8_t stack)
{
    MPHELL_ASSERT_ALWAYS(field_elt_ispower_ui (src, 3, k, stack), "field_elt_cube_root \
            : src is not a cube in k");
    switch(k->type)
    {
        case FP :
            fp_elt_cube_root((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src), k->param, stack);
            break;

        case FP2 :
            fp2_elt_cube_root((fp2_elt_ptr)dst, (fp2_elt_srcptr)src, k->param, stack);
            break;

        case FP3 :
            fp3_elt_cube_root((fp3_elt_ptr)dst, (fp3_elt_srcptr)src, k->param, stack);
            break;
    }
}

void
field_elt_unity_nth_root (fe_ptr dst, const block n, field_ptr k, uint8_t stack)
{
    switch(k->type)
    {
        case FP :
            fp_elt_unity_nth_root((fp_elt_ptr)(*dst), n, k->param, stack);
            break;

        case FP2 :
            fp2_elt_unity_nth_root((fp2_elt_ptr)dst, n, k->param, stack);
            break;

        case FP3 :
            fp3_elt_unity_nth_root((fp3_elt_ptr)dst, n, k->param, stack);
            break;
    }
}

/**********************************DIVISION***********************************/

void
field_elt_inv (fe_ptr dst, fe_srcptr src, field_srcptr k, uint8_t stack)
{
    switch(k->type)
    {
        case FP :
            fp_elt_inv((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src), k->param, stack);
            break;
 
        case FP2 :
            fp2_elt_inv((fp2_elt_ptr)dst, (fp2_elt_srcptr)src, k->param, stack);
            break;
 
        case FP3 :
            fp3_elt_inv((fp3_elt_ptr)dst, (fp3_elt_srcptr)src, k->param, stack);
            break;
    }
}

void
field_elt_inv_fp_elt (fe_ptr dst, fe_srcptr src, field_srcptr k, uint8_t stack)
{
    switch(k->type)
    {
        case FP :
            fp_elt_inv((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src), k->param, stack);
            break;
 
        case FP2 :
            fp2_elt_inv_fp_elt((fp2_elt_ptr)dst, (fp_elt_srcptr)(*src), k->param, stack);
            break;
 
        case FP3 :
            fp3_elt_inv_fp_elt((fp3_elt_ptr)dst, (fp_elt_srcptr)(*src), k->param, stack);
            break;
    }
}

/* Not tested */
/*void*/
/*field_elt_inv_pm2 (fe_ptr dst, fe_srcptr src, field_srcptr k, uint8_t stack)*/
/*{*/
/*    char * pm2;*/
/*    pm2=malloc((k2->bit_size+1)*sizeof(char));*/
/*    switch(k->type)*/
/*    {*/
/*        case FP :*/
/*            {*/
/*            fp_get_pm2(pm2, k->param);*/
/*            break;*/
/*            }*/
/*        case FP2 :*/
/*            {*/
/*            fp2_get_pm2(pm2, k->param);*/
/*            break;*/
/*            }*/
/* */
/*        case FP3 :*/
/*            {*/
/*            fp3_get_pm2(pm2, k->param);*/
/*            break;*/
/*            }*/
/*        default :*/
/*            {*/
/*            break;*/
/*            }*/
/*    }*/
/*    field_elt y, dst2, dst3;*/

/*   */

/*    int i, len;*/
/*    field_elt_get_pool_elt(&y, (field_ptr)k, stack);*/
/*    field_elt_get_pool_elt(&dst2, (field_ptr)k, stack);*/
/*    field_elt_get_pool_elt(&dst3, (field_ptr)k, stack);*/
/*    */
/*    field_elt_copy(y, src, k);*/
/*    field_elt_set_one(dst2, k);*/
/*    */
/*    len=(int)strlen(pm2);*/
/*    */
/*    for(i=len-1; i>=0; i--)*/
/*    { */
/*        field_elt_sqr(dst2, dst2, k, stack);*/
/*        if (pm2[i]=='1')*/
/*        {*/
/*            field_elt_mul(dst2, dst2, y, k, stack);*/
/*        }*/
/*        else*/
/*        {*/
/*            field_elt_mul(dst3, y, dst3, k, stack);*/
/*        }*/
/*    }*/
/*    field_elt_copy(dst, dst2, k);*/
/*    field_elt_mul(dst3, dst2, src, k, stack);*/
/*    if(!field_elt_isone(dst3,k))*/
/*    {*/
/*        printf("\nInversion echouee: src*src^{-1}=");*/
/*        field_elt_print(dst3, 10, true, k, stack);*/
/*    }*/
/*    field_elt_relax_pool_elt(&y, (field_ptr)k, stack);*/
/*    field_elt_relax_pool_elt(&dst2, (field_ptr)k, stack);*/
/*    field_elt_relax_pool_elt(&dst3, (field_ptr)k, stack);*/
/*}*/

void
field_elt_div (fe_ptr dst, fe_srcptr src1, fe_srcptr src2, field_srcptr k, uint8_t stack)
{
    switch(k->type)
    {
        case FP :
            fp_elt_div((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src1), (fp_elt_srcptr)(*src2), k->param, stack);
            break;

        case FP2 :
            fp2_elt_div((fp2_elt_ptr)dst, (fp2_elt_srcptr)src1, (fp2_elt_srcptr)src2, k->param, stack);
            break;

        case FP3 :
            fp3_elt_div((fp3_elt_ptr)dst, (fp3_elt_srcptr)src1, (fp3_elt_srcptr)src2, k->param, stack);
            break;
    }
}

void
field_elt_div_fp_elt (fe_ptr dst, fe_srcptr src1, fe_srcptr src2, field_srcptr k, uint8_t stack)
{
    switch(k->type)
    {
        case FP :
            fp_elt_div((fp_elt_ptr)(*dst), (fp_elt_srcptr)(*src1), (fp_elt_srcptr)(*src2), k->param, stack);
            break;

        case FP2 :
            fp2_elt_div_fp_elt((fp2_elt_ptr)dst, (fp2_elt_srcptr)src1, (fp_elt_srcptr)(*src2), k->param, stack);
            break;

        case FP3 :
            fp3_elt_div_fp_elt((fp3_elt_ptr)dst, (fp3_elt_srcptr)src1, (fp_elt_srcptr)(*src2), k->param, stack);
            break;
    }
}