Quelle vec8bit.h Sprache: C

/****************************************************************************
**
**  This file is part of GAP, a system for computational discrete algebra.
**
**  Copyright of GAP belongs to its developers, whose names are too numerous
**  to list here. Please refer to the COPYRIGHT file for details.
**
**  SPDX-License-Identifier: GPL-2.0-or-later
*/

#ifndef GAP_VEC8BIT_H
#define GAP_VEC8BIT_H

#include "objects.h"
#include "opers.h"

/****************************************************************************
**
*F  RewriteGF2Vec( <vec>, <q> ) . . .
**                convert a GF(2) vector into a GF(2^k) vector in place
**
*/
void RewriteGF2Vec(Obj vec, UInt q);

/****************************************************************************
**
*F  CopyVec8Bit( <list>, <mut> ) . . . . . . . . . . . . . . copying function
**
*/
Obj CopyVec8Bit(Obj list, UInt mut);

/****************************************************************************
**
*F  IS_VEC8BIT_REP( <obj> ) . . .  check that <obj> is in 8bit GFQ vector rep
*/
extern Obj IsVec8bitRep;

EXPORT_INLINE BOOL IS_VEC8BIT_REP(Obj obj)
{
    return TNUM_OBJ(obj) == T_DATOBJ && True == DoFilter(IsVec8bitRep, obj);
}

/****************************************************************************
**
*F  PlainVec8Bit( <list> ) . . . convert an 8bit vector into an ordinary list
**
**  'PlainVec8Bit' converts the  vector <list> to a plain list.
*/
void PlainVec8Bit(Obj list);

/****************************************************************************
**
*F  ASS_VEC8BIT( <list>, <pos>, <elm> ) . . . .  set an elm of an 8bit vector
**
*/
void ASS_VEC8BIT(Obj list, Obj pos, Obj elm);

/****************************************************************************
**
*F  ZeroVec8Bit( <list> ) . . . make a new 8 bit vector
**
*/
Obj ZeroVec8Bit(UInt q, UInt len, UInt mut);

/****************************************************************************
**
**  Low-level access, needed for meataxe64 package
**
*/
Obj GetFieldInfo8Bit(UInt q);

/****************************************************************************
**
*F  LEN_VEC8BIT( <vec> ) . . . . . . . . . . . . length of an 8 bit GF vector
**
**  'LEN_VEC8BIT' returns the logical length of the 8bit GFQ vector <list>,
**  as a C integer.
*/
EXPORT_INLINE UInt LEN_VEC8BIT(Obj list)
{
    return (UInt)CONST_ADDR_OBJ(list)[1];
}

/****************************************************************************
**
*F  SET_LEN_VEC8BIT( <vec>, <len> )  . . . . set length of an 8 bit GF vector
**
**  'SET_LEN_VEC8BIT' sets the logical length of the 8bit GFQ vector <vec>,
**  to the C integer <len>.
**
*/
EXPORT_INLINE void SET_LEN_VEC8BIT(Obj list, UInt len)
{
    ADDR_OBJ(list)[1] = (Obj)len;
}

/****************************************************************************
**
*F  FIELD_VEC8BIT( <vec> ) . . . . . . . . . field size of an 8 bit GF vector
**
**  'FIELD_VEC8BIT' returns the field size Q of the 8bit GFQ vector <list>,
**  as a C integer.
*/
EXPORT_INLINE UInt FIELD_VEC8BIT(Obj list)
{
    return (UInt)CONST_ADDR_OBJ(list)[2];
}

/****************************************************************************
**
*F  SET_FIELD_VEC8BIT( <vec>, <q> )  . . set field size of an 8 bit GF vector
**
**  'SET_FIELD_VEC8BIT' sets the field size of the 8bit GFQ vector <vec>,
**  to the C integer <q>.
*/
EXPORT_INLINE void SET_FIELD_VEC8BIT(Obj list, UInt q)
{
    ADDR_OBJ(list)[2] = (Obj)q;
}

/****************************************************************************
**
*F  BLOCKS_VEC8BIT( <list> ) . . . . . . . . first block of a 8bit GFQ vector
**
**  returns a pointer to the start of the data of the 8bit GFQ vector
*/
EXPORT_INLINE UInt * BLOCKS_VEC8BIT(Obj list)
{
    return (UInt *)(ADDR_OBJ(list) + 3);
}

EXPORT_INLINE const UInt * CONST_BLOCKS_VEC8BIT(Obj list)
{
    return (const UInt *)(CONST_ADDR_OBJ(list) + 3);
}

/****************************************************************************
**
*F  BYTES_VEC8BIT( <list> ) . . . . . . . . . first byte of a 8bit GFQ vector
**
**  returns a pointer to the start of the data of the 8bit GFQ vector
*/
EXPORT_INLINE UInt1 * BYTES_VEC8BIT(Obj list)
{
    return (UInt1 *)BLOCKS_VEC8BIT(list);
}

EXPORT_INLINE const UInt1 * CONST_BYTES_VEC8BIT(Obj list)
{
    return (const UInt1 *)CONST_BLOCKS_VEC8BIT(list);
}

/****************************************************************************
**
*F  Q_FIELDINFO_8BIT( <obj> )       . . . access to fields in structure
*F  P_FIELDINFO_8BIT( <obj> )
*F  ELS_BYTE_FIELDINFO_8BIT( <obj> )
*F  SETELT_FIELDINFO_8BIT( <obj> )
*F  GETELT_FIELDINFO_8BIT( <obj> )
*F  ADD_FIELDINFO_8BIT( <obj> )
*F  SET_XXX_FIELDINFO_8BIT( <obj>, <xxx> ) . . .setters needed by ANSI
**                                         needed for scalar but not pointers
*/
struct FieldInfo8Bit {
    Obj   type;
    UInt  q;                        // field size, 3 <= q <= 256
    UInt  p;                        // prime
    UInt  d;                        // degree; q = p^d
    UInt  e;                        // number of elements per byte; <= 5
    Obj   FFE_FELT[256];            // position in GAP < order  by number
    Obj   GAPSEQ[256];              // numbering from FFV
    UInt1 FELT_FFE[256];            // immediate FFE by number
    UInt1 SETELT[256 * 256 * 5];    // set element lookup (5 is largest possible value for e)
    UInt1 GETELT[256 * 5];          // get element lookup
    UInt1 SCALAR[256 * 256];        // scalar multiply
    UInt1 INNER[256 * 256];         // inner product
    UInt1 PMULL[256 * 256];         // one lot of polynomial multiply data
    UInt1 PMULU[256 * 256];         // the other lot of polynomial data (only used if e > 1)
    UInt1 ADD[256 * 256];           // add byte (only used if p > 2)
};

typedef struct FieldInfo8Bit * FieldInfo8BitPtr;
typedef const struct FieldInfo8Bit * ConstFieldInfo8BitPtr;

EXPORT_INLINE FieldInfo8BitPtr FIELDINFO_8BIT(Obj info)
{
    return (FieldInfo8BitPtr)ADDR_OBJ(info);
}

EXPORT_INLINE ConstFieldInfo8BitPtr CONST_FIELDINFO_8BIT(Obj info)
{
    return (ConstFieldInfo8BitPtr)CONST_ADDR_OBJ(info);
}

EXPORT_INLINE UInt Q_FIELDINFO_8BIT(Obj info)
{
    return CONST_FIELDINFO_8BIT(info)->q;
}

EXPORT_INLINE UInt P_FIELDINFO_8BIT(Obj info)
{
    return CONST_FIELDINFO_8BIT(info)->p;
}

EXPORT_INLINE UInt D_FIELDINFO_8BIT(Obj info)
{
    return CONST_FIELDINFO_8BIT(info)->d;
}

EXPORT_INLINE UInt ELS_BYTE_FIELDINFO_8BIT(Obj info)
{
    return CONST_FIELDINFO_8BIT(info)->e;
}

EXPORT_INLINE const Obj *CONST_FFE_FELT_FIELDINFO_8BIT(Obj info)
{
    return CONST_FIELDINFO_8BIT(info)->FFE_FELT;
}

EXPORT_INLINE Obj FFE_FELT_FIELDINFO_8BIT(Obj info, UInt i)
{
    GAP_ASSERT(i < 256);
    return CONST_FIELDINFO_8BIT(info)->FFE_FELT[i];
}

EXPORT_INLINE const Obj * GAPSEQ_FELT_FIELDINFO_8BIT(Obj info)
{
    return CONST_FIELDINFO_8BIT(info)->GAPSEQ;
}

EXPORT_INLINE void SET_GAPSEQ_FELT_FIELDINFO_8BIT(Obj info, UInt i, Obj d)
{
    GAP_ASSERT(i < 256);
    FIELDINFO_8BIT(info)->GAPSEQ[i] = d;
}

EXPORT_INLINE const UInt1 * FELT_FFE_FIELDINFO_8BIT(Obj info)
{
    return CONST_FIELDINFO_8BIT(info)->FELT_FFE;
}

EXPORT_INLINE const UInt1 * SETELT_FIELDINFO_8BIT(Obj info)
{
    return CONST_FIELDINFO_8BIT(info)->SETELT;
}

EXPORT_INLINE const UInt1 * GETELT_FIELDINFO_8BIT(Obj info)
{
    return CONST_FIELDINFO_8BIT(info)->GETELT;
}

EXPORT_INLINE const UInt1 * SCALAR_FIELDINFO_8BIT(Obj info)
{
    return CONST_FIELDINFO_8BIT(info)->SCALAR;
}

EXPORT_INLINE const UInt1 * INNER_FIELDINFO_8BIT(Obj info)
{
    return CONST_FIELDINFO_8BIT(info)->INNER;
}

EXPORT_INLINE const UInt1 * PMULL_FIELDINFO_8BIT(Obj info)
{
    return CONST_FIELDINFO_8BIT(info)->PMULL;
}

EXPORT_INLINE const UInt1 * PMULU_FIELDINFO_8BIT(Obj info)
{
    return CONST_FIELDINFO_8BIT(info)->PMULU;
}

EXPORT_INLINE const UInt1 * ADD_FIELDINFO_8BIT(Obj info)
{
    return CONST_FIELDINFO_8BIT(info)->ADD;
}

/****************************************************************************
**
*F * * * * * * * * * * * * * initialize module * * * * * * * * * * * * * * *
*/

/****************************************************************************
**
*F  InitInfoVec8bit() . . . . . . . . . . . . . . . . table of init functions
*/
StructInitInfo * InitInfoVec8bit(void);

#endif    // GAP_VEC8BIT_H

quality99%

¤ Dauer der Verarbeitung: 0.25 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.