#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cf_assert.h"
#include "cf_defs.h"
#include "gf_tabutil.h"
#include "cf_util.h"
#include "canonicalform.h"
#include "variable.h"
#include "gfops.h"
#include "singext.h"

Functions
static CanonicalForm	intVec2CF (int degree, int *coeffs, int level)

void	set_gftable_dir (char *d)

static void	gf_get_table (int p, int n)

void	gf_setcharacteristic (int p, int n, char name)

long	gf_gf2ff (long a)

int	gf_gf2ff (int a)

bool	gf_isff (long a)

bool	gf_isff (int a)

Variables
const int	gf_maxtable = 63001

const int	gf_maxbuffer = 200

const int	gf_primes_len = 42

VAR int	gf_q = 0

VAR int	gf_p = 0

VAR int	gf_n = 0

VAR int	gf_q1 = 0

VAR int	gf_m1 = 0

VAR char	gf_name = 'Z'

VAR unsigned short *	gf_table = 0

INST_VAR CanonicalForm	gf_mipo =0L

STATIC_VAR char *	gftable_dir

Function Documentation

◆ gf_get_table()

static void gf_get_table	(	int	p,
		int	n
	)

static

Definition at line 76 of file gfops.cc.

{
    char buffer[gf_maxbuffer];
    int q = ipower( p, n );
 
    // do not read the table a second time
    if ( gf_q == q )
    {
        return;
    }
 
    if ( gf_table == 0 )
        gf_table = new unsigned short[gf_maxtable];
 
    // try to open file
    char *gffilename;
    FILE * inputfile;
    if (gftable_dir)
    {
      sprintf( buffer, "gftables/%d", q);
      gffilename = (char *)malloc(strlen(gftable_dir) + strlen(buffer) + 1);
      STICKYASSERT(gffilename,"out of memory");
      strcpy(gffilename,gftable_dir);
      strcat(gffilename,buffer);
      inputfile = fopen( gffilename, "r" );
    }
    else
    {
      sprintf( buffer, "gftables/%d", q );
      gffilename = buffer;
#ifndef SINGULAR
      inputfile = fopen( buffer, "r" );
#else
      inputfile = feFopen( buffer, "r" );
#endif
    }
    if (!inputfile)
    {
      fprintf(stderr,"can not open GF(q) addition table: %s\n",gffilename);
      STICKYASSERT(inputfile, "can not open GF(q) table");
    }
 
    // read ID
    char * bufptr;
    char * success;
    success = fgets( buffer, gf_maxbuffer, inputfile );
    STICKYASSERT( success, "illegal table (reading ID)" );
    STICKYASSERT( strcmp( buffer, "@@ factory GF(q) table @@\n" ) == 0, "illegal table" );
    // read p and n from file
    int pFile, nFile;
    success = fgets( buffer, gf_maxbuffer, inputfile );
    STICKYASSERT( success, "illegal table (reading p and n)" );
    sscanf( buffer, "%d %d", &pFile, &nFile );
    STICKYASSERT( p == pFile && n == nFile, "illegal table" );
    // skip (sic!) factory-representation of mipo
    // and terminating "; "
    bufptr = (char *)strchr( buffer, ';' ) + 2;
    // read simple representation of mipo
    int i, degree;
    sscanf( bufptr, "%d", &degree );
    bufptr = (char *)strchr( bufptr, ' ' ) + 1;
    int * mipo = NEW_ARRAY(int,degree+1);
    for ( i = 0; i <= degree; i++ )
    {
        sscanf( bufptr, "%d", mipo + i );
        bufptr = (char *)strchr( bufptr, ' ' ) + 1;
    }
 
    gf_p = p; gf_n = n;
    gf_q = q; gf_q1 = q-1;
    gf_mipo = intVec2CF( degree, mipo, 1 );
    DELETE_ARRAY(mipo);
 
    // now for the table
    int k, digs = gf_tab_numdigits62( gf_q );
    i = 1;
    while ( i < gf_q )
    {
        success = fgets( buffer, gf_maxbuffer, inputfile );
        STICKYASSERT( strlen( buffer ) - 1 == (size_t)digs * 30, "illegal table" );
        bufptr = buffer;
        k = 0;
        while ( i < gf_q && k < 30 )
        {
            gf_table[i] = convertback62( bufptr, digs );
            bufptr += digs;
            if ( gf_table[i] == gf_q )
            {
                if ( i == gf_q1 )
                    gf_m1 = 0;
                else
                    gf_m1 = i;
            }
            i++; k++;
        }
    }
    gf_table[0] = gf_table[gf_q1];
    gf_table[gf_q] = 0;
 
    (void)fclose( inputfile );
}

◆ gf_gf2ff() [1/2]

int gf_gf2ff ( int a )

Definition at line 231 of file gfops.cc.

{
    if ( gf_iszero( a ) )
        return 0;
    else
    {
        // starting from z^0=1, step through the table
        // counting the steps until we hit z^a or z^0
        // again.  since we are working in char(p), the
        // latter is guaranteed to be fulfilled.
        int i = 0, ff = 1;
        do
        {
            if ( i == a )
                return ff;
            ff++;
            i = gf_table[i];
        } while ( i != 0 );
        return -1;
    }
}

◆ gf_gf2ff() [2/2]

long gf_gf2ff ( long a )

Definition at line 209 of file gfops.cc.

{
    if ( gf_iszero( a ) )
        return 0;
    else
    {
        // starting from z^0=1, step through the table
        // counting the steps until we hit z^a or z^0
        // again.  since we are working in char(p), the
        // latter is guaranteed to be fulfilled.
        long i = 0, ff = 1;
        do
        {
            if ( i == a )
                return ff;
            ff++;
            i = gf_table[i];
        } while ( i != 0 );
        return -1;
    }
}

◆ gf_isff() [1/2]

bool gf_isff ( int a )

Definition at line 264 of file gfops.cc.

{
    if ( gf_iszero( a ) )
        return true;
    else
    {
        // z^a in GF(p) iff (z^a)^p-1=1
        return gf_isone( gf_power( a, gf_p - 1 ) );
    }
}

◆ gf_isff() [2/2]

bool gf_isff ( long a )

Definition at line 253 of file gfops.cc.

{
    if ( gf_iszero( a ) )
        return true;
    else
    {
        // z^a in GF(p) iff (z^a)^p-1=1
        return gf_isone( gf_power( a, gf_p - 1 ) );
    }
}

◆ gf_setcharacteristic()

void gf_setcharacteristic	(	int	p,
		int	n,
		char	name
	)

Definition at line 202 of file gfops.cc.

{
    ASSERT( gf_valid_combination( p, n ), "illegal immediate GF(q)" );
    gf_name = name;
    gf_get_table( p, n );
}

◆ intVec2CF()

static CanonicalForm intVec2CF	(	int	degree,
		int *	coeffs,
		int	level
	)

static

Definition at line 58 of file gfops.cc.

{
    int i;
    CanonicalForm result;
    for ( i = 0; i <= degree; i++ )
    {
        result += CanonicalForm( coeffs[ i ] ) * power( Variable( level ), degree - i );
    }
    return result;
}

◆ set_gftable_dir()

void set_gftable_dir ( char * d )

Definition at line 71 of file gfops.cc.

                               {
    gftable_dir = d;
  }

Variable Documentation

◆ gf_m1

VAR int gf_m1 = 0

Definition at line 51 of file gfops.cc.

◆ gf_maxbuffer

const int gf_maxbuffer = 200

Definition at line 31 of file gfops.cc.

◆ gf_maxtable

const int gf_maxtable = 63001

Definition at line 30 of file gfops.cc.

◆ gf_mipo

INST_VAR CanonicalForm gf_mipo =0L

Definition at line 56 of file gfops.cc.

◆ gf_n

VAR int gf_n = 0

Definition at line 49 of file gfops.cc.

◆ gf_name

VAR char gf_name = 'Z'

Definition at line 52 of file gfops.cc.

◆ gf_p

VAR int gf_p = 0

Definition at line 48 of file gfops.cc.

◆ gf_primes_len

const int gf_primes_len = 42

Definition at line 33 of file gfops.cc.

◆ gf_q

VAR int gf_q = 0

Definition at line 47 of file gfops.cc.

◆ gf_q1

VAR int gf_q1 = 0

Definition at line 50 of file gfops.cc.

◆ gf_table

VAR unsigned short* gf_table = 0

Definition at line 54 of file gfops.cc.

◆ gftable_dir

STATIC_VAR char* gftable_dir

Definition at line 69 of file gfops.cc.

Functions

Variables