/***************************************************************************
                                                                           *
Copyright 2013 CertiVox UK Ltd.                                           *
                                                                           *
This file is part of CertiVox MIRACL Crypto SDK.                           *
                                                                           *
The CertiVox MIRACL Crypto SDK provides developers with an                 *
extensive and efficient set of cryptographic functions.                    *
For further information about its features and functionalities please      *
refer to http://www.certivox.com                                           *
                                                                           *
* The CertiVox MIRACL Crypto SDK is free software: you can                 *
  redistribute it and/or modify it under the terms of the                  *
  GNU Affero General Public License as published by the                    *
  Free Software Foundation, either version 3 of the License,               *
  or (at your option) any later version.                                   *
                                                                           *
* The CertiVox MIRACL Crypto SDK 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 Affero General Public License for more details.              *
                                                                           *
* You should have received a copy of the GNU Affero General Public         *
  License along with CertiVox MIRACL Crypto SDK.                           *
  If not, see <http://www.gnu.org/licenses/>.                              *
                                                                           *
You can be released from the requirements of the license by purchasing     *
a commercial license. Buying such a license is mandatory as soon as you    *
develop commercial activities involving the CertiVox MIRACL Crypto SDK     *
without disclosing the source code of your own applications, or shipping   *
the CertiVox MIRACL Crypto SDK with a closed source product.               *
                                                                           *
***************************************************************************/
/*
 *    MIRACL C++ Header file gf2m.h
 *
 *    AUTHOR  : M.Scott
 *    
 *    PURPOSE : Definition of class GF2m (Arithmetic in the field GF(2^m)
 *
 *    NOTE:   : The field basis is set dynamically via the modulo() routine.
 *              Must be used with big.h and big.cpp
 */

#ifndef GF2M_H
#define GF2M_H

#include "big.h"

/*
#ifdef GF2MS
#define MR_INIT_GF2M memset(mem,0,mr_big_reserve(1,GF2MS)); fn=(big)mirvar_mem_variable(mem,0,GF2MS); 
#define MR_CLONE_GF2M(x) fn->len=x->len; for (int i=0;i<GF2MS;i++) fn->w[i]=x->w[i];
#define MR_ZERO_GF2M {fn->len=0; for (int i=0;i<GF2MS;i++) fn->w[i]=0;} 
#else
#define MR_INIT_GF2M mem=(char *)memalloc(1); fn=(big)mirvar_mem(mem,0);
#define MR_CLONE_GF2M(x) copy(x,fn);
#define MR_ZERO_GF2M zero(fn);
#endif
*/


#ifdef GF2MS
#define MR_INIT_GF2M fn=&b; b.w=a; b.len=GF2MS; 
#define MR_CLONE_GF2M(x) b.len=x->len; for (int i=0;i<GF2MS;i++) a[i]=x->w[i]; 
#define MR_ZERO_GF2M {b.len=0; for (int i=0;i<GF2MS;i++) a[i]=0;}  
#else
#define MR_INIT_GF2M fn=mirvar(0);
#define MR_CLONE_GF2M(x) copy(x,fn);
#define MR_ZERO_GF2M zero(fn);
#endif

class GF2m
{
    big fn;
/*
#ifdef GF2MS
    char mem[mr_big_reserve(1,GF2MS)];
#else
    char *mem;
#endif
*/

#ifdef GF2MS
    mr_small a[GF2MS];
    bigtype b;
#endif

public:
    GF2m()              {MR_INIT_GF2M MR_ZERO_GF2M}
    GF2m(int j)         {MR_INIT_GF2M if (j==0) MR_ZERO_GF2M else {convert(j,fn); reduce2(fn,fn);}}
    GF2m(const Big& c)  {MR_INIT_GF2M reduce2(c.getbig(),fn); }   /* Big -> GF2m */
    GF2m(big& c)        {MR_INIT_GF2M MR_CLONE_GF2M(c)}
    GF2m(const GF2m& c) {MR_INIT_GF2M MR_CLONE_GF2M(c.fn)}
    GF2m(char *s)       {MR_INIT_GF2M cinstr(fn,s); reduce2(fn,fn);}
   
    GF2m& operator=(const GF2m& c)  {MR_CLONE_GF2M(c.fn) return *this;}
    GF2m& operator=(big c)          {MR_CLONE_GF2M(c) return *this;}

    GF2m& operator=(int i)   {if (i==0) MR_ZERO_GF2M else {convert(i,fn); reduce2(fn,fn);} return *this;}
    GF2m& operator=(const Big& b)   { reduce2(b.getbig(),fn); return *this; }
    GF2m& operator=(char *s)        { cinstr(fn,s); reduce2(fn,fn); return *this;}
    GF2m& operator++() {incr2(fn,1,fn); return *this; }

    GF2m& operator+=(const GF2m& c)
    {
#ifdef GF2MS
        for (int i=0;i<GF2MS;i++)
            fn->w[i]^=c.fn->w[i];
        fn->len=GF2MS;
        if (fn->w[GF2MS-1]==0) mr_lzero(fn);
#else
        add2(fn,c.fn,fn);
#endif
        return *this;
    }

    GF2m& operator+=(int i) {incr2(fn,i,fn); return *this; }
    GF2m& operator*=(const GF2m& b) {modmult2(fn,b.fn,fn); return *this;}
    GF2m& square() {modsquare2(fn,fn); return *this;}
    GF2m& inverse() {inverse2(fn,fn); return *this;} 
    BOOL quadratic(GF2m& b) {return quad2(fn,b.fn);}
    int degree() {return degree2(fn);}

    BOOL iszero() const;
    BOOL isone() const;
    operator Big() {return (Big)fn;}   /* GF2m -> Big */
    friend big getbig(GF2m& z) {return z.fn;}
    friend int trace(GF2m & z) {return trace2(z.fn);}

    GF2m& operator/=(const GF2m&);
    
    friend GF2m operator+(const GF2m&,const GF2m&);
    friend GF2m operator+(const GF2m&,int);
    friend GF2m operator*(const GF2m&,const GF2m&);
    friend GF2m operator/(const GF2m&,const GF2m&);
    
    friend BOOL operator==(const GF2m& b1,const GF2m& b2)
    { if (mr_compare(b1.fn,b2.fn)==0) return TRUE; else return FALSE;}
    friend BOOL operator!=(const GF2m& b1,const GF2m& b2)
    { if (mr_compare(b1.fn,b2.fn)!=0) return TRUE; else return FALSE;}
     
    friend GF2m square(const GF2m&);
    friend GF2m inverse(const GF2m&);
    friend GF2m pow(const GF2m&,int);
    friend GF2m sqrt(const GF2m&);
    friend GF2m halftrace(const GF2m&);
	friend GF2m quad(const GF2m&);
#ifndef MR_NO_RAND
    friend GF2m random2(void);
#endif
    friend GF2m gcd(const GF2m&,const GF2m&);

    friend void kar2x2(const GF2m*,const GF2m*,GF2m*);
    friend void kar3x3(const GF2m*,const GF2m*,GF2m*);

    friend int degree(const GF2m& x) {return degree2(x.fn);}
    
    ~GF2m()   
    {
      //  zero(fn);
#ifndef GF2MS    
        mr_free(fn); 
#endif  
    }
};
#ifndef MR_NO_RAND
extern GF2m random2(void);
#endif
#endif