MeatAxe: src/meataxe.h Source File

MeatAxe 2.4

- Main Page
- Related Pages
- Modules
- Data Structures

- File List

src/meataxe.h

    00001 /* ============================= C MeatAxe ==================================
    00002    File:        $Id: meataxe.h,v 1.3 2007-09-03 21:35:22 mringe Exp $
    00003    Comment:     MeatAxe library external interfaces.
    00004    --------------------------------------------------------------------------
    00005    (C) Copyright 2004 Michael Ringe, Lehrstuhl D fuer Mathematik,
    00006    RWTH Aachen, Germany  <mringe@math.rwth-aachen.de>
    00007    This program is free software; see the file COPYING for details.
    00008    ========================================================================== */
    00009
    00010 #ifndef MEATAXE_H_INCLUDED
    00011 #define MEATAXE_H_INCLUDED
    00012
    00013 #include <stdio.h>
    00014 #include <stdarg.h>
    00015
    00016 #define MTX_VERSION "2.4"
    00017
    00018 #if defined GCC
    00019 #define MTX_PRINTF_ATTRIBUTE(f,v) __attribute__((format(printf,f,v)))
    00020 #else
    00021 #define MTX_PRINTF_ATTRIBUTE(f,v)
    00022 #endif
    00023
    00024 extern char *MtxVersion;
    00030 #define FM_READ     0x01
    00031 #define FM_CREATE   0x02
    00032 #define FM_APPEND   0x03
    00033 #define FM_TEXT     0x10
    00034 #define FM_LIB      0x20
    00035 #define FM_NOERROR  0x40
    00036
    00040 int SysCreateDirectory(const char *name);
    00041 int SysGetPid();
    00042 void SysInit(void);
    00043 void *SysMalloc(size_t nbytes);
    00044 FILE *SysFopen(const char *name, int mode);
    00045 void SysFree(void *x);
    00046 int SysFseek(FILE *f,long pos);
    00047 int SysFseekRelative(FILE *file, long distance);
    00048 void *SysRealloc(void *buf, size_t nbytes);
    00049 int SysReadLong32(FILE *f, long *buf, int n);
    00050 #define SysReadLong SysReadLong32
    00051 int SysReadLongX(FILE *f, long *buf, int n);
    00052 int SysRemoveDirectory(const char *name);
    00053 int SysRemoveFile(const char *name);
    00054 void SysSetTimeLimit(long nsecs);
    00055 long SysTimeUsed(void);
    00056 int SysWriteLong32(FILE *f, const long *buf, int n);
    00057 #define SysWriteLong SysWriteLong32
    00058 int SysWriteLongX(FILE *f, const long *buf, int n);
    00059
    00060 #define ALLOC(type) ((type *) SysMalloc(sizeof(type)))
    00061 #define NALLOC(type,n) ((type *) SysMalloc((size_t)(n) * sizeof(type)))
    00062 #define NREALLOC(x,type,n)\
    00063         ((type *) SysRealloc(x,(size_t)(n) * sizeof(type)))
    00064 #define FREE(x) SysFree(x)
    00065
    00070 /* ---------------------------------------------------------------------------------------------- */
    00071
    00077 /* Data types and constants
    00078    ------------------------ */
    00079
    00080 #if ZZZ==0
    00081
    00082 typedef unsigned char FEL;
    00083 typedef FEL *PTR;
    00084 #define FF_ZERO ((FEL)0)
    00085 #define FF_ONE ((FEL)1)
    00086 #define ZZZVERSION 6
    00087
    00088 #elif ZZZ==1
    00089
    00090 typedef unsigned short FEL;
    00091 typedef unsigned short *PTR;
    00092 #define FF_ZERO ((FEL)0xFFFF)
    00093 #define FF_ONE ((FEL)0)
    00094 #define ZZZVERSION 0x101
    00095
    00096 #else
    00097
    00098 #error "ZZZ undefined"
    00099
    00100 #endif
    00101
    00102 /* Kernel variables and functions
    00103    ------------------------------ */
    00104
    00105 extern int FfOrder;
    00106 extern int FfChar;
    00107 extern FEL FfGen;
    00108 extern int FfNoc;
    00109 extern size_t FfCurrentRowSize;
    00110
    00111
    00112 /* Arithmetic */
    00113 FEL FfAdd(FEL a, FEL b);
    00114 FEL FfSub(FEL a, FEL b);
    00115 FEL FfMul(FEL a, FEL b);
    00116 FEL FfDiv(FEL a, FEL b);
    00117 FEL FfNeg(FEL a);
    00118 FEL FfInv(FEL a);
    00119
    00120 int FfMakeTables(int field);
    00121 int FfSetField(int field);
    00122 int FfSetNoc(int noc);
    00123
    00124
    00125 void FfAddMulRow(PTR dest, PTR src, FEL f);
    00126 PTR FfAddRow(PTR dest, PTR src);
    00127 PTR FfAddRowPartial(PTR dest, PTR src, int first, int len);
    00128 PTR FfAlloc(int nor);
    00129 int FfCmpRows(PTR p1, PTR p2);
    00130 void FfCleanRow(PTR row, PTR matrix, int nor, const int *piv);
    00131 void FfCleanRow2(PTR row, PTR matrix, int nor, const int *piv, PTR row2);
    00132 void FfCleanRowAndRepeat(PTR row, PTR mat, int nor, const int *piv,
    00133     PTR row2, PTR mat2);
    00134 void FfCopyRow(PTR dest, PTR src);
    00135 FEL FfEmbed(FEL a, int subfield);
    00136 FEL FfExtract(PTR row, int col);
    00137 void FfExtractColumn(PTR mat,int nor,int col,PTR result);
    00138 int FfFindPivot(PTR row, FEL *mark);
    00139 void FfFree(PTR x);
    00140 FEL FfFromInt(int l);
    00141 PTR FfGetPtr(PTR base, int row);
    00142 void FfInsert(PTR row, int col, FEL mark);
    00143 void FfMulRow(PTR row, FEL mark);
    00144 FILE *FfReadHeader(const char *name, int *fld, int *nor, int *noc);
    00145 int FfReadRows(FILE *f, PTR buf, int n);
    00146 FEL FfRestrict(FEL a, int subfield);
    00147 size_t FfRowSize(int noc);
    00148 FEL FfScalarProduct(PTR a, PTR b);
    00149 int FfSeekRow(FILE *f, int pos);
    00150 int FfStepPtr(PTR *x);
    00151 void FfSwapRows(PTR dest, PTR src);
    00152 const char *FfToGap(FEL f);
    00153 int FfToInt(FEL f);
    00154 size_t FfTrueRowSize(int noc);
    00155 FILE *FfWriteHeader(const char *name, int fld, int nor, int noc);
    00156 int FfWriteRows(FILE *f, PTR buf, int n);
    00157
    00158
    00159 /* --------------------------------------------------------------------------
    00160    Macro versions of kernel functions
    00161    -------------------------------------------------------------------------- */
    00162
    00163
    00164 #if ZZZ==0
    00165
    00166 extern FEL mtx_tmult[256][256];
    00167 extern FEL mtx_tadd[256][256];
    00168 extern FEL mtx_taddinv[256], mtx_tmultinv[256];
    00169 extern FEL mtx_tffirst[256][2];
    00170 extern FEL mtx_textract[8][256];
    00171 extern FEL mtx_tnull[8][256];
    00172 extern FEL mtx_tinsert[8][256];
    00173 extern long mtx_embedord[4];
    00174 extern FEL mtx_embed[4][16];
    00175 extern FEL mtx_restrict[4][256];
    00176
    00177 #define FfAdd(a,b) ((FEL)mtx_tadd[(int)(unsigned char)a][(int)(unsigned char)b])
    00178 #define FfDiv(a,b) FfMul((a),FfInv(b))
    00179 #define FfInv(a) (mtx_tmultinv[(int)(unsigned char)a])
    00180 #define FfMul(a,b) ((FEL)mtx_tmult[(int)(unsigned char)a][(int)(unsigned char)b])
    00181 #define FfNeg(a) (mtx_taddinv[(int)(unsigned char)a])
    00182 #define FfSub(a,b) FfAdd((a),FfNeg(b))
    00183
    00184 #elif ZZZ==1
    00185
    00186 #define FfExtract(row,col) ((FEL)((row)[(col)-1]))
    00187 #define FfInsert(row,col,mark) ((void)((row)[(col)-1] = mark))
    00188
    00189
    00190 #endif
    00191
    00194 /* ------------------------------------------------------------------
    00195    Other low-level functions (zzz2.c)
    00196    ------------------------------------------------------------------ */
    00197
    00198 void FfMapRow(PTR row, PTR matrix, int nor, PTR result);
    00199 void FfPermRow(PTR row, const long *perm, PTR result);
    00200 int FfSumAndIntersection(PTR wrk1, int *nor1, int *nor2, PTR wrk2, int *piv);
    00201
    00202
    00203 /* ------------------------------------------------------------------
    00204    Library initialization and cleanup
    00205    ------------------------------------------------------------------ */
    00206
    00207 extern int Mtx_IsInitialized;
    00208 extern int Mtx_IsX86;
    00209 extern int MtxOpt_UseOldWordGenerator;
    00210
    00211 int MtxInitLibrary();
    00212 void MtxCleanupLibrary();
    00213
    00214
    00228 typedef struct {
    00229     char *S;    /* pointer to NUL terminated string */
    00230 } String;
    00231
    00232 String StrAlloc(size_t initial_capacity);
    00233 void StrFree(String *s);
    00234 void StrAppend(String *s, const char *text);
    00235 MTX_PRINTF_ATTRIBUTE(2,3)
    00236 void StrAppendF(String *s, const char *fmt, ...);
    00237 MTX_PRINTF_ATTRIBUTE(2,3)
    00238 void StrPrintF(String *s, const char *fmt, ...);
    00239
    00245 /* ------------------------------------------------------------------
    00246    Application framework
    00247    ------------------------------------------------------------------ */
    00248
    00249 extern char MtxBinDir[];        /* MeatAxe library directory */
    00250 extern char MtxLibDir[];        /* MeatAxe program directory */
    00251
    00252 #define APP_MAX_ARGS 50
    00253
    00275 typedef struct
    00276 {
    00277     const char *Name;
    00278     const char *Description;
    00279     const char *Help;
    00280 } MtxApplicationInfo_t;
    00281
    00282
    00283
    00284
    00291 typedef struct
    00292 {
    00293     MtxApplicationInfo_t const *AppInfo;
    00294     int OrigArgC;
    00295     const char **OrigArgV;
    00296     int ArgC;
    00297     const char **ArgV;
    00298     int OptEnd;
    00299     unsigned long IsDone[APP_MAX_ARGS];
    00300     const char *OptArg;
    00301     int OptInd;
    00302     char TempDirName[200];
    00303 } MtxApplication_t;
    00304
    00305
    00306 MtxApplication_t *AppAlloc(MtxApplicationInfo_t const *ai, int argc, const char **argv);
    00307 int AppFree(MtxApplication_t *a);
    00308 int AppGetOption(MtxApplication_t *app, const char *spec);
    00309 int AppGetCountedOption(MtxApplication_t *app, const char *spec);
    00310 const char *AppGetTextOption(MtxApplication_t *app, const char *spec,
    00311     const char *dflt);
    00312 int AppGetIntOption(MtxApplication_t *app, const char *spec, int dflt,
    00313     int min, int max);
    00314 int AppGetArguments(MtxApplication_t *app, int min_argc, int max_argc);
    00315 const char *AppCreateTempDir(MtxApplication_t *app);
    00316
    00317 #define MTX_COMMON_OPTIONS_SYNTAX \
    00318     "[<Options>]"
    00319
    00320 #define MTX_COMMON_OPTIONS_DESCRIPTION \
    00321     "    -Q ...................... Quiet, no messages\n" \
    00322     "    -V ...................... Verbose, more messages\n" \
    00323     "    -T <MaxTime> ............ Set CPU time limit [s]\n"
    00324
    00325
    00326 /* ------------------------------------------------------------------
    00327    Messages and error handling
    00328    ------------------------------------------------------------------ */
    00329                                 /* Error message codes (%E arguments) */
    00330 #define MTX_ERR_NOMEM       1   /* Not enough memory */
    00331 #define MTX_ERR_GAME_OVER   2   /* Time limit exceeded */
    00332 #define MTX_ERR_DIV0        8   /* Division by 0 or singular Matrix */
    00333 #define MTX_ERR_FILEFMT     24  /* Bad format */
    00334 #define MTX_ERR_BADARG      31  /* Bad argument */
    00335 #define MTX_ERR_RANGE       33  /* Out of range */
    00336 #define MTX_ERR_NOTECH      34  /* Matrix not in chelon form */
    00337 #define MTX_ERR_NOTSQUARE   35  /* Matrix not square */
    00338 #define MTX_ERR_INCOMPAT    36  /* Arguments are incompatible */
    00339 #define MTX_ERR_BADUSAGE    41  /* Bad command line */
    00340 #define MTX_ERR_OPTION      42  /* Bad usage of option */
    00341 #define MTX_ERR_NARGS       43  /* Bad number of arguments */
    00342 #define MTX_ERR_NOTMATRIX   51  /* Not a matrix */
    00343 #define MTX_ERR_NOTPERM     53  /* Not a permutation */
    00344
    00345
    00346
    00350 typedef struct { const char *Name; const char *BaseName; } MtxFileInfo_t;
    00351
    00355 typedef struct { const MtxFileInfo_t *FileInfo; int LineNo; const char *Text; }
    00356     MtxErrorRecord_t;
    00357
    00358 typedef void MtxErrorHandler_t(const MtxErrorRecord_t *);
    00359
    00360 #define MTX_DEFINE_FILE_INFO \
    00361     static MtxFileInfo_t Mtx_ThisFile = { __FILE__, NULL };
    00362
    00363 int MtxError(MtxFileInfo_t *fi, int line, const char *text, ...);
    00364 MtxErrorHandler_t *MtxSetErrorHandler(MtxErrorHandler_t *h);
    00365
    00366
    00367 #define MTX_ERROR(msg) MtxError(&Mtx_ThisFile,__LINE__,msg)
    00368 #define MTX_ERROR1(msg,a1) MtxError(&Mtx_ThisFile,__LINE__,msg,a1)
    00369 #define MTX_ERROR2(msg,a1,a2) MtxError(&Mtx_ThisFile,__LINE__,msg,a1,a2)
    00370 #define MTX_ERROR3(msg,a1,a2,a3) MtxError(&Mtx_ThisFile,__LINE__,msg,a1,a2,a3)
    00371 #define MTX_ERROR4(msg,a1,a2,a3,a4) MtxError(&Mtx_ThisFile,__LINE__,\
    00372     msg,a1,a2,a3,a4)
    00373 #define MTX_ERROR5(msg,a1,a2,a3,a4,a5) MtxError(&Mtx_ThisFile,__LINE__,\
    00374     msg,a1,a2,a3,a4,a5)
    00375 #define MTX_ERROR7(msg,a1,a2,a3,a4,a5,a6,a7) MtxError(&Mtx_ThisFile,__LINE__,\
    00376     msg,a1,a2,a3,a4,a5,a6,a7)
    00377
    00378
    00379 #define MTX_VERIFY(e) ((void)((e) ||\
    00380     MtxError(&Mtx_ThisFile,__LINE__,"Assertion failed: %s",#e)))
    00381
    00382 #ifdef _DEBUG
    00383 #define DEBUG 1
    00384 #endif
    00385
    00386 #ifdef DEBUG
    00387 #define MTX_ASSERT(e) MTX_VERIFY(e)
    00388 #else
    00389 #define MTX_ASSERT(e)
    00390 #undef PARANOID
    00391 #endif
    00392
    00393
    00394
    00395 /* ------------------------------------------------------------------
    00396    Messages
    00397    ------------------------------------------------------------------ */
    00398
    00399 int MtxFormatMessage(char *buf, int bufsize, const char *msg, va_list al);
    00400 int MtxPrintMessage(FILE *f, const char *fmt, ...);
    00401
    00402 extern int MtxMessageLevel;
    00403 #define MSG0 (MtxMessageLevel >= 0)
    00404 #define MSG1 (MtxMessageLevel >= 1)
    00405 #define MSG2 (MtxMessageLevel >= 2)
    00406 #define MSG3 (MtxMessageLevel >= 3)
    00407 #define MSG4 (MtxMessageLevel >= 4)
    00408 #define MESSAGE(level,args)\
    00409   (MtxMessageLevel>=(level) ? ( printf args , fflush(stdout), 1) : 0 )
    00410
    00411
    00412 /* ------------------------------------------------------------------
    00413    Miscellaneous
    00414    ------------------------------------------------------------------ */
    00415
    00416 void MtxRandomInit(unsigned seed);
    00417 long int MtxRandom(void);
    00418 int MtxRandomInt(int max);
    00419 long gcd(long a, long b);
    00420 long lcm(long a, long b);
    00421
    00422
    00423 /* ------------------------------------------------------------------
    00424    Structured text files (stfXXX.c)
    00425    ------------------------------------------------------------------ */
    00426
    00431 typedef struct
    00432 {
    00433     FILE *File;
    00434     char *LineBuf;
    00435     char *GetPtr;
    00436     int LineBufSize;
    00437     int OutPos;
    00438     int LineNo;
    00439 } StfData;
    00440
    00441 int StfClose(StfData *f);
    00442 StfData *StfOpen(const char *name, int mode);
    00443
    00444 int StfPut(StfData *f, const char *text);
    00445 int StfPutInt(StfData *f, int value);
    00446 int StfPutString(StfData *f, const char *text);
    00447 int StfPutVector(StfData *f, int size, const int *value);
    00448 int StfBeginEntry(StfData *f, const char *name);
    00449 int StfEndEntry(StfData *f);
    00450 int StfWriteValue(StfData *f, const char *name, const char *value);
    00451 int StfWriteInt(StfData *f, const char *name, int value);
    00452 int StfWriteString(StfData *f, const char *name, const char *value);
    00453 int StfWriteVector(StfData *f, const char *name, int size, const int *value);
    00454
    00455 int StfReadLine(StfData *f);
    00456 const char *StfGetName(StfData *f);
    00457 int StfGetInt(StfData *f, int *buf);
    00458 int StfGetString(StfData *f, char *buf, size_t bufsize);
    00459 int StfMatch(StfData *f, const char *pattern);
    00460 int StfGetVector(StfData *f, int *bufsize, int *buf);
    00461
    00462
    00463 /* ------------------------------------------------------------------
    00464    MeatAxe files
    00465    ------------------------------------------------------------------ */
    00466
    00470 typedef struct
    00471 {
    00472     unsigned long Magic;
    00473     int Field;
    00474     int Nor;
    00475     int Noc;
    00476     FILE *File;
    00477     char *Name;
    00478 } MtxFile_t;
    00479
    00480 int MfIsValid(const MtxFile_t *file);
    00481 MtxFile_t *MfOpen(const char *name);
    00482 MtxFile_t *MfCreate(const char *name, int field, int nor, int noc);
    00483 int MfClose(MtxFile_t *file);
    00484 int MfReadLong(MtxFile_t *f, long *buf, int nrows);
    00485 int MfReadRows(MtxFile_t *f, PTR buf, int nrows);
    00486 int MfWriteLong(MtxFile_t *f, const long *buf, int count);
    00487 int MfWriteRows(MtxFile_t *f, PTR buf, int nrows);
    00488
    00489
    00490 /* ---------------------------------------------------------------------------------------------- */
    00491
    00492 typedef struct
    00493 {
    00494     unsigned long Magic;
    00495     int Field;
    00496     int Nor;
    00497     int Noc;
    00498     PTR Data;
    00499     size_t RowSize;
    00500     int *PivotTable;
    00501 } Matrix_t;
    00502
    00503 Matrix_t *MatAdd(Matrix_t *dest, const Matrix_t *src);
    00504 Matrix_t *MatAddMul(Matrix_t *dest, const Matrix_t *src, FEL coeff);
    00505 Matrix_t *MatAlloc(int field, int nor, int noc);
    00506 int MatClean(Matrix_t *mat, const Matrix_t *sub);
    00507 int MatCompare(const Matrix_t *a, const Matrix_t *b);
    00508 int MatCopyRegion(Matrix_t *dest, int destrow, int destcol,
    00509     const Matrix_t *src, int row1, int col1, int nrows, int ncols);
    00510 Matrix_t *MatCut(const Matrix_t *src, int row1, int col1, int nrows, int ncols);
    00511 Matrix_t *MatCutRows(const Matrix_t *src, int row1, int nrows);
    00512 Matrix_t *MatDup(const Matrix_t *src);
    00513 int MatEchelonize(Matrix_t *mat);
    00514 int MatFree(Matrix_t *mat);
    00515 PTR MatGetPtr(const Matrix_t *mat, int row);
    00516 Matrix_t *MatId(int fl, int nor);
    00517 Matrix_t *MatInverse(const Matrix_t *src);
    00518 int MatIsValid(const Matrix_t *m);
    00519 Matrix_t *MatLoad(const char *fn);
    00520 Matrix_t *MatMul(Matrix_t *dest, const Matrix_t *src);
    00521 Matrix_t *MatMulScalar(Matrix_t *dest, FEL coeff);
    00522 long MatNullity(const Matrix_t *mat);
    00523 long MatNullity__(Matrix_t *mat);
    00524 Matrix_t *MatNullSpace(const Matrix_t *mat);
    00525 Matrix_t *MatNullSpace_(Matrix_t *mat, int flags);
    00526 Matrix_t *MatNullSpace__(Matrix_t *mat);
    00527 int MatOrder(const Matrix_t *mat);
    00528 int MatPivotize(Matrix_t *mat);
    00529 Matrix_t *MatPower(const Matrix_t *mat, long n);
    00530 void MatPrint(const char *name, const Matrix_t *m);
    00531 Matrix_t *MatRead(FILE *f);
    00532 int MatSave(const Matrix_t *mat, const char *fn);
    00533 FEL MatTrace(const Matrix_t *mat);
    00534 Matrix_t *MatTransposed(const Matrix_t *src);
    00535 int MatWrite(const Matrix_t *mat, FILE *f);
    00536
    00537 /* For internal use only */
    00538 void Mat_DeletePivotTable(Matrix_t *mat);
    00539
    00540
    00541
    00542 /* ------------------------------------------------------------------
    00543    Greased matrices
    00544    ------------------------------------------------------------------ */
    00545
    00551 typedef struct {
    00552     long ***tabs; /* tables for different remainders
    00553                      of byte numbers mod grrows */
    00554     int *nrvals;  /* number of values produced by each table */
    00555     int nrtabs;   /* number of tables used */
    00556 } GrExtractionTable_t;
    00557
    00558 const GrExtractionTable_t *GrGetExtractionTable(int fl,int grrows);
    00559
    00560
    00565 typedef struct
    00566 {
    00567     unsigned long Magic;
    00568     int Field, Nor, Noc;
    00569     int GrRows;                 /* Grease level (# of rows, 0=no grease) */
    00570     int GrBlockSize;            /* Vectors per block (= Field^GrRows) */
    00571     int NumVecs;                /* Total number of vectors in <PrecalcData> */
    00572     PTR PrecalcData;            /* Precalculated data */
    00573     const GrExtractionTable_t
    00574         *ExtrTab;               /* Extraction table */
    00575     int MPB;                    /* Number of marks per byte */
    00576 } GreasedMatrix_t;
    00577
    00578 void GrMapRow(PTR v,GreasedMatrix_t *M, PTR w);
    00579 GreasedMatrix_t *GrMatAlloc(const Matrix_t *m, int gr_rows);
    00580 int GrMatFree(GreasedMatrix_t *mat);
    00581 int GrMatIsValid(const GreasedMatrix_t *mat);
    00582
    00583
    00584
    00585 /* ------------------------------------------------------------------
    00586    Permutations
    00587    ------------------------------------------------------------------ */
    00588
    00590 typedef struct
    00591 {
    00592     unsigned long Magic;
    00593     int Degree;
    00594     long *Data;
    00595 } Perm_t;
    00596
    00597
    00598 Perm_t *PermAlloc(int deg);
    00599 int PermCompare(const Perm_t *a, const Perm_t *b);
    00600 Perm_t *PermDup(const Perm_t *src);
    00601 int PermFree(Perm_t *p);
    00602 Perm_t *PermInverse(const Perm_t *src);
    00603 int PermIsValid(const Perm_t *p);
    00604 Perm_t *PermLoad(const char *fn);
    00605 Perm_t *PermMul(Perm_t *dest, const Perm_t *src);
    00606 int PermOrder(const Perm_t *perm);
    00607 void PermPrint(const char *name, const Perm_t *perm);
    00608 Perm_t *PermPower(const Perm_t *p, int n);
    00609 Perm_t *PermRead(FILE *f);
    00610 int PermSave(const Perm_t *perm, const char *fn);
    00611 int PermWrite(const Perm_t *perm, FILE *f);
    00612
    00613 void Perm_ConvertOld(long *data, int len);
    00614
    00615 /* ------------------------------------------------------------------
    00616    Polynomials
    00617    ------------------------------------------------------------------ */
    00618
    00619 typedef struct
    00620 {
    00621     unsigned long Magic;
    00622     int Field;
    00623     int Degree;
    00624     FEL *Data;
    00626     int BufSize;
    00627 }
    00628 Poly_t;
    00629
    00630
    00631 Poly_t *PolAdd(Poly_t *dest, const Poly_t *src);
    00632 Poly_t *PolAlloc(int fl, int n);
    00633 int PolCompare(const Poly_t *a, const Poly_t *b);
    00634 Poly_t *PolDerive(Poly_t *pol);
    00635 Poly_t *PolDivMod(Poly_t *a, const Poly_t *b);
    00636 Poly_t *PolDup(const Poly_t *p);
    00637 int PolFree(Poly_t *p);
    00638 Poly_t *PolGcd(const Poly_t *a, const Poly_t *b);
    00639 int PolGcdEx(const Poly_t *a, const Poly_t *b, Poly_t **result);
    00640 int PolIsValid(const Poly_t *p);
    00641 Poly_t *PolMod(Poly_t *a, const Poly_t *b);
    00642 void Pol_Normalize(Poly_t *p);
    00643 Poly_t *PolLoad(const char *fn);
    00644 Poly_t *PolMul(Poly_t *dest, const Poly_t *src);
    00645 void PolPrint(char *name, const Poly_t *p);
    00646 Poly_t *PolRead(FILE *f);
    00647 int PolSave(const Poly_t *pol, const char *fn);
    00648 int PolWrite(const Poly_t *p, FILE *f);
    00649
    00650
    00651
    00652 /* ------------------------------------------------------------------
    00653    Factored polynomials
    00654    ------------------------------------------------------------------ */
    00655
    00656 typedef struct
    00657 {
    00658     unsigned long Magic;
    00659     int NFactors;
    00660     int BufSize;
    00661     Poly_t **Factor;
    00662     int *Mult;
    00663 } FPoly_t;
    00664
    00665 FPoly_t *FpAlloc();
    00666 int FpFree(FPoly_t *x);
    00667 int FpIsValid(const FPoly_t *p);
    00668 FPoly_t *FpMul(FPoly_t *dest, const FPoly_t *src);
    00669 FPoly_t *FpMulP(FPoly_t *dest, const Poly_t *src, int pwr);
    00670 int FpPrint(const char *name, const FPoly_t *p);
    00671
    00672 /* ---------------------------------------------------------------------------------------------- */
    00673
    00674 typedef struct
    00675 {
    00676     unsigned long Magic;
    00677     int Size;
    00678     int BufSize;
    00679     long Data[1];
    00681 } BitString_t;
    00683 BitString_t *BsAlloc(int size);
    00684 int BsAnd(BitString_t *dest, const BitString_t *src);
    00685 int BsClear(BitString_t *bs, int i);
    00686 int BsClearAll(BitString_t *bs);
    00687 int BsCompare(const BitString_t *a, const BitString_t *b);
    00688 BitString_t *BsCopy(BitString_t *dest, const BitString_t *src);
    00689 BitString_t *BsDup(const BitString_t *src);
    00690 int BsFree(BitString_t *bs);
    00691 int BsIntersectionCount(const BitString_t *a, const BitString_t *b);
    00692 int BsIsSub(const BitString_t *a, const BitString_t *b);
    00693 int BsIsValid(const BitString_t *bs);
    00694 int BsMinus(BitString_t *dest, const BitString_t *src);
    00695 int BsOr(BitString_t *dest, const BitString_t *src);
    00696 void BsPrint(const char *name, const BitString_t *bs);
    00697 BitString_t *BsRead(FILE *f);
    00698 int BsSet(BitString_t *bs, int i);
    00699 int BsTest(const BitString_t *bs, int i);
    00700 int BsWrite(BitString_t *bs, FILE *f);
    00701
    00702 #ifndef DEBUG
    00703
    00704 #define BS_BPL (sizeof(long) * 8)
    00705 #define BsSet(bs,i) ((bs)->Data[(i) / BS_BPL] |= 1L << ((i) % BS_BPL))
    00706 #define BsClear(bs,i) ((bs)->Data[(i) / BS_BPL] &= ~(1L << ((i) % BS_BPL)))
    00707 #define BsTest(bs,i) (((bs)->Data[(i) / BS_BPL] & (1L << ((i) % BS_BPL))) != 0 ? 1 : 0)
    00708
    00709 #endif
    00710
    00711
    00712 /* ------------------------------------------------------------------
    00713    Sets
    00714    ------------------------------------------------------------------ */
    00715
    00716 typedef struct
    00717 {
    00718     unsigned long Magic;
    00719     int Size;
    00720     int BufSize;
    00721     long *Data;
    00722 } Set_t;
    00723
    00724
    00725 Set_t *SetAlloc();
    00726 int SetContains(const Set_t *set, long elem);
    00727 Set_t *SetDup(const Set_t *s);
    00728 int SetFree(Set_t *x);
    00729 int SetInsert(Set_t *set, long elem);
    00730 int SetIsValid(const Set_t *s);
    00731 int SetPrint(char *name, const Set_t *s);
    00732
    00733
    00734 /* ------------------------------------------------------------------
    00735    Integer matrices
    00736    ------------------------------------------------------------------ */
    00737
    00738 typedef struct
    00739 {
    00740     unsigned long Magic;
    00741     int Nor;
    00742     int Noc;
    00743     long *Data;
    00744 } IntMatrix_t;
    00745
    00746 IntMatrix_t *ImatAlloc(int nor, int noc);
    00747 int ImatFree(IntMatrix_t *mat);
    00748 int ImatIsValid(const IntMatrix_t *m);
    00749 IntMatrix_t *ImatLoad(const char *fn);
    00750 IntMatrix_t *ImatRead(FILE *f);
    00751 int ImatSave(const IntMatrix_t *mat, const char *file_name);
    00752 int ImatWrite(const IntMatrix_t *mat, FILE *f);
    00753
    00754
    00755 /* --------------------------------------------------------------------------
    00756    Polymorphic objects
    00757    -------------------------------------------------------------------------- */
    00758
    00759 void *XDup(void *a);
    00760 int XIsCompatible(void *a, void *b);
    00761 void XFree(void *a);
    00762 void *XInverse(void *a);
    00763 void *XLoad(const char *fn);
    00764 void XMul(void *a, void *b);
    00765 long XOrder(void *a);
    00766 void *XPower(void *a, int n);
    00767 int XSave(void *a, const char *fn);
    00768
    00769
    00770
    00771
    00772
    00773
    00774
    00775 /* --------------------------------------------------------------------------
    00776    Matrix sets
    00777    -------------------------------------------------------------------------- */
    00778
    00783 typedef struct
    00784 {
    00785     Matrix_t *Matrix;
    00786     int PivRow;
    00787     int PivCol;
    00788     FEL PivMark;
    00789 } MatrixSetElement_t;
    00790
    00791
    00795 typedef struct {
    00796     unsigned long Magic;
    00797     int Len;
    00798     MatrixSetElement_t *List;
    00799 } MatrixSet_t;
    00800
    00801 MatrixSet_t *MsAlloc();
    00802 int MsClean(const MatrixSet_t *set, Matrix_t *mat);
    00803 int MsCleanAndAppend(MatrixSet_t *set, Matrix_t *mat);
    00804 int MsFree(MatrixSet_t *set);
    00805 int MsIsValid(const MatrixSet_t *set);
    00806
    00807
    00808
    00809 /* --------------------------------------------------------------------------
    00810    Matrix representations
    00811    -------------------------------------------------------------------------- */
    00812
    00813 typedef struct
    00814 {
    00815     unsigned long Magic;
    00816     int NGen;
    00817     Matrix_t **Gen;
    00818 } MatRep_t;
    00819
    00820 #define MR_COPY_GENERATORS  0x0001
    00821
    00822 int MrAddGenerator(MatRep_t *rep, Matrix_t *gen, int flags);
    00823 MatRep_t *MrAlloc(int ngen, Matrix_t **gen, int flags);
    00824 int MrChangeBasis(MatRep_t *rep, const Matrix_t *trans);
    00825 int MrIsValid(const MatRep_t *rep);
    00826 int MrFree(MatRep_t *rep);
    00827 MatRep_t *MrLoad(const char *basename, int ngen);
    00828 int MrSave(const MatRep_t *rep, const char *basename);
    00829 MatRep_t *MrTransposed(const MatRep_t *rep);
    00830
    00831
    00832
    00833 /* ------------------------------------------------------------------
    00834    The word generator
    00835    ------------------------------------------------------------------ */
    00836
    00837 typedef struct
    00838 {
    00839     const MatRep_t *Rep;
    00840     Matrix_t *Basis[8];
    00841     int N2[8];
    00842     int *Description;
    00843 } WgData_t;
    00844
    00845
    00846 WgData_t *WgAlloc(const MatRep_t *rep);
    00847 int *WgDescribeWord(WgData_t *b, long n);
    00848 int WgFree(WgData_t *b);
    00849 Matrix_t *WgMakeWord(WgData_t *b, long n);
    00850 void WgMakeFingerPrint(WgData_t *b, int fp[6]);
    00851 const char *WgSymbolicName(WgData_t *b, long n);
    00852
    00853
    00854
    00855
    00856
    00857 /* ------------------------------------------------------------------
    00858    Spin-up, Split, Quotients, etc.
    00859    ------------------------------------------------------------------ */
    00860
    00861 #define SF_FIRST        0x0001  /* Try only the first seed vector */
    00862 #define SF_EACH         0x0002  /* Try each seed vector */
    00863 #define SF_MAKE         0x0004  /* Try all 1-dimensional subspaces */
    00864 #define SF_SUB          0x0010  /* Try until finding a proper subspace */
    00865 #define SF_CYCLIC       0x0020  /* Try until finding a cyclic vector */
    00866 #define SF_COMBINE      0x0040  /* Combine the spans */
    00867 #define SF_SEED_MASK    0x000F
    00868 #define SF_MODE_MASK    0x00F0
    00869 #define SF_STD          0x0100  /* Spin up 'canonically' */
    00870
    00871 Matrix_t *QProjection(const Matrix_t *subspace, const Matrix_t *vectors);
    00872 Matrix_t *QAction(const Matrix_t *sub, const Matrix_t *gen);
    00873 Matrix_t *SAction(const Matrix_t *sub, const Matrix_t *gen);
    00874
    00875 typedef struct
    00876 {
    00877     int MaxSubspaceDimension;
    00878     int MaxTries;
    00879     int Result;
    00880 } SpinUpInfo_t;
    00881
    00882 int SpinUpInfoInit(SpinUpInfo_t *info);
    00883 Matrix_t *SpinUp(const Matrix_t *seed, const MatRep_t *rep, int flags,
    00884     IntMatrix_t **script, SpinUpInfo_t *info);
    00885 Matrix_t *SpinUpWithScript(const Matrix_t *seed, const MatRep_t *rep,
    00886     const IntMatrix_t *script);
    00887 int Split(Matrix_t *subspace, const MatRep_t *rep,
    00888           MatRep_t **sub, MatRep_t **quot);
    00889
    00890 int ConvertSpinUpScript(IntMatrix_t *script);
    00891
    00892 Matrix_t *SpinUpWithPermutations(const Matrix_t *seed, int ngen,
    00893     const Perm_t **gen, int flags, IntMatrix_t **script, SpinUpInfo_t *info);
    00894
    00895
    00896 /* ------------------------------------------------------------------
    00897    Seed vector generator
    00898    ------------------------------------------------------------------ */
    00899
    00900 long MakeSeedVector(const Matrix_t *basis, long lastno, PTR vec);
    00901
    00902
    00903
    00904 /* ------------------------------------------------------------------
    00905    Miscellaneous algorithms
    00906    ------------------------------------------------------------------ */
    00907
    00908 Matrix_t *MatInsert_(Matrix_t *mat, const Poly_t *pol);
    00909 Matrix_t *MatInsert(const Matrix_t *mat, const Poly_t *pol);
    00910 int IsSubspace(const Matrix_t *sub, const Matrix_t *space, int ngen);
    00911
    00912 Matrix_t *MatTensor(const Matrix_t *m1, const Matrix_t *m2);
    00913 int MatrixToVector(const Matrix_t *mat, Matrix_t *vecs, int n);
    00914 Matrix_t *VectorToMatrix(Matrix_t *vecs, int n, int noc);
    00915 Matrix_t *TensorMap(Matrix_t *vec, const Matrix_t *a, const Matrix_t *b);
    00916
    00917 int StablePower(const Matrix_t *mat, int *pwr, Matrix_t **ker);
    00918 int StablePower_(Matrix_t *mat, int *pwr, Matrix_t **ker);
    00919
    00920
    00921
    00922 /* ------------------------------------------------------------------
    00923    Polynomial factorization (Berlekamp algorithm)
    00924    ------------------------------------------------------------------ */
    00925
    00926 FPoly_t *Factorization(const Poly_t *pol);
    00927
    00928
    00929
    00930 /* ------------------------------------------------------------------
    00931    Characteristic and minimal polynomials (charpol.c, minpol.c)
    00932    ------------------------------------------------------------------ */
    00933
    00934 extern long CharPolSeed;
    00935 Poly_t *CharPolFactor(const Matrix_t *mat);
    00936 FPoly_t *CharPol(const Matrix_t *mat);
    00937 Poly_t *MinPolFactor(Matrix_t *mat);
    00938 FPoly_t *MinPol(Matrix_t *mat);
    00939
    00940
    00941
    00942 /* ------------------------------------------------------------------
    00943    The lattice package
    00944    ------------------------------------------------------------------ */
    00950 #define MAXGEN 20       /* Max. number of generators */
    00951 #define LAT_MAXCF 200   /* Max. number of composition factors */
    00952 #define MAXCYCL 30000   /* Max. number of cyclic submodules */
    00953 #define MAXDOTL 90000   /* Max. number of dotted lines */
    00954 #define MAXNSUB 20000   /* Max. number of submodules */
    00955 #define LAT_MAXBASENAME 100
    00956
    00957 typedef struct
    00958 {
    00959     long dim, num, mult;
    00960     long idword;                /* Identifying word */
    00961     Poly_t *idpol;
    00962     long peakword;              /* Peak word */
    00963     Poly_t *peakpol;
    00964     long nmount;                /* Number of mountains */
    00965     long ndotl;                 /* Number of dotted lines */
    00966     long spl;                   /* Degree of splitting field */
    00967 }
    00968 CfInfo;
    00969
    00970 typedef struct
    00971 {
    00972     char BaseName[LAT_MAXBASENAME];
    00973     int Field;
    00974     int NGen;
    00975     int NCf;
    00976     CfInfo Cf[LAT_MAXCF];
    00977     int NSocles;
    00978     int *Socle;
    00979     int NHeads;
    00980     int *Head;
    00981 } Lat_Info;
    00982
    00983 int Lat_ReadInfo(Lat_Info *li, const char *basename);
    00984 int Lat_WriteInfo(const Lat_Info *li);
    00985 const char *Lat_CfName(const Lat_Info *li, int cf);
    00986 int Lat_AddHead(Lat_Info *li, int *mult);
    00987 int Lat_AddSocle(Lat_Info *li, int *mult);
    00988
    00989
    00990 #define LAT_RG_INVERT           0x0001  /* Invert generators */
    00991 #define LAT_RG_TRANSPOSE        0x0002  /* Transpose generators */
    00992 #define LAT_RG_STD              0x0004  /* Use standard form */
    00993
    00994 MatRep_t *Lat_ReadCfGens(Lat_Info *info, int cf, int flags);
    00995
    01001 /* ------------------------------------------------------------------
    01002    Tensor condensation package
    01003    ------------------------------------------------------------------ */
    01004
    01013 typedef struct
    01014 {
    01015     char NameM[LAT_MAXBASENAME];
    01016     char NameN[LAT_MAXBASENAME];
    01017     int Dim;
    01018     int NCf;
    01019     int CfIndex[2][LAT_MAXCF];
    01020 } TkData_t;
    01021
    01022 int TK_ReadInfo(TkData_t *tki, const char *name);
    01023 int TK_WriteInfo(TkData_t *tki, const char *name);
    01024
    01025
    01026
    01027
    01028 /* !!!!!!!!!!!!!!! 2.3 STUFF below !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
    01029 /* !!!!!!!!!!!!!!! 2.3 STUFF below !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
    01030 /* !!!!!!!!!!!!!!! 2.3 STUFF below !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
    01031
    01032
    01033
    01034 /* ------------------------------------------------------------------
    01035    Return codes
    01036    ------------------------------------------------------------------ */
    01037
    01038 #define EXIT_OK         0       /* Exit code: normal end */
    01039 #define EXIT_ERR        1       /*            error */
    01040
    01041
    01042
    01043 /* ------------------------------------------------------------------
    01044    Function operating on representations and vector spaces
    01045    ------------------------------------------------------------------ */
    01046
    01047 int IsIsomorphic(const MatRep_t *rep1, const CfInfo *info1,
    01048     const MatRep_t *rep2, Matrix_t  **trans, int use_pw);
    01049 int MakeEndomorphisms(const MatRep_t *rep, const Matrix_t *nsp,
    01050     Matrix_t *endo[]);
    01051 Matrix_t *HomogeneousPart(MatRep_t *m, MatRep_t *s, Matrix_t *npw,
    01052     const IntMatrix_t *op, int dimends);
    01053
    01054
    01055
    01056 /* ------------------------------------------------------------------
    01057    Lattice drawing functions
    01058    ------------------------------------------------------------------ */
    01059
    01063 typedef struct
    01064 {
    01065     double PosX, PosY;          /* Position [0..1] */
    01066     unsigned long UserData;     /* User-defined attributes */
    01067     int Layer;                  /* Layer number */
    01068     double Score;               /* Used in optimization */
    01069     int ScoreCount;
    01070 } LdNode_t;
    01071
    01075 typedef struct
    01076 {
    01077     int NNodes;
    01078     LdNode_t *Nodes;
    01079     int *IsSub;         /* Incidence relation, <NNodes> * <NNodes> entries */
    01080     int *LayerNo;       /* Layer numbers */
    01081     int NLayers;
    01082 } LdLattice_t;
    01083
    01084 #define LD_ISSUB(l,i,k) ((l)->IsSub[(i) * (l)->NNodes + (k)])
    01085
    01086 LdLattice_t *LdAlloc(int num_nodes);
    01087 int LdFree(LdLattice_t *l);
    01088 int LdAddIncidence(LdLattice_t *lat, int sub, int sup);
    01089 int LdSetPositions(LdLattice_t *l);
    01090
    01091
    01092
    01093
    01094 /* OLD STUFF */
    01095 int ChangeBasisOLD(const Matrix_t *M, int ngen, const Matrix_t *gen[],
    01096         Matrix_t *newgen[]);
    01097
    01098
    01099 #endif  /* !defined(_MEATAXE_H_) */
    01100
    01101