Changeset 89f209 in git


Ignore:
Timestamp:
Jul 30, 2014, 1:50:55 AM (10 years ago)
Author:
Oleksandr Motsak <motsak@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '8a337797cc4177aa8747d661d5c4214ea2095dac')
Children:
e6f4c664f288908426da693a1f2d3efceebb7cbc
Parents:
62a54bfd4802c1ca5c195eb34a4b7bfb231af0c3
git-author:
Oleksandr Motsak <motsak@mathematik.uni-kl.de>2014-07-30 01:50:55+02:00
git-committer:
Oleksandr Motsak <motsak@mathematik.uni-kl.de>2014-07-30 02:06:16+02:00
Message:
Fixed doxygen descriptions of some files/classes/methods
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • kernel/polys.cc

    r62a54b r89f209  
    88#include "polys.h"
    99
     10/// Widely used global variable which specifies the current polynomial ring for Singular interpreter and legacy implementatins.
     11/// @Note: one should avoid using it in newer designs, for example due to possible problems in parallelization with threads.
    1012ring  currRing = NULL;
    1113
  • kernel/polys.h

    r62a54b r89f209  
    1 /*! \file kernel/polys.h KernelCommon: compatiblity layer for all operations with polys
    2  
     1/*! \file kernel/polys.h Compatiblity layer for legacy polynomial operations (over @ref currRing)
     2 
     3 Macro defines for legacy polynomial operations used in @ref kernel_page and @ref singular_page. 
     4 They take no ring argument since they work with @ref currRing by default.
     5 Notice that they have different prefix: `p` instead of `p_`.
     6
     7 See also related global ring variable and the correct ring changeing routine:
     8 - \ref currRing
     9 - \ref rChangeCurrRing
    310*/
    411
     
    2128 ***************************************************************/
    2229
    23 // deletes old coeff before setting the new one
     30/// deletes old coeff before setting the new one
    2431#define pSetCoeff(p,n)      p_SetCoeff(p,n,currRing)
    2532
    26 // Order
     33/// Order
    2734#define pGetOrder(p)        p_GetOrder(p, currRing)
    2835
    29 // Component
     36/// Component
    3037#define pGetComp(p)         __p_GetComp(p, currRing)
    3138#define pSetComp(p,v)       p_SetComp(p,v, currRing)
    3239
    33 // Exponent
     40/// Exponent
    3441#define pGetExp(p,i)        p_GetExp(p, i, currRing)
    3542#define pSetExp(p,i,v)      p_SetExp(p, i, v, currRing)
     
    4956 *
    5057 ***************************************************************/
    51 // allocates the space for a new monomial -- no initialization !!!
     58/// allocates the space for a new monomial -- no initialization !!!
    5259#define pNew()          p_New(currRing)
    53 // allocates a new monomial and initializes everything to 0
     60/// allocates a new monomial and initializes everything to 0
    5461#define pInit()         p_Init(currRing)
    55 // like pInit, except that expvector is initialized to that of p,
    56 // p must be != NULL
     62/// like pInit, except that expvector is initialized to that of p,
     63/// p must be != NULL
    5764#define pLmInit(p)  p_LmInit(p, currRing)
    58 // returns newly allocated copy of Lm(p), coef is copied, next=NULL,
    59 // p might be NULL
     65/// returns newly allocated copy of Lm(p), coef is copied, next=NULL,
     66/// p might be NULL
    6067#define pHead(p)        p_Head(p, currRing)
    61 // frees the space of the monomial m, assumes m != NULL
    62 // coef is not freed, m is not advanced
     68/// frees the space of the monomial m, assumes m != NULL
     69/// coef is not freed, m is not advanced
    6370static inline void pLmFree(poly p)    {p_LmFree(p, currRing);}
    64 // like pLmFree, but advances p
     71/// like pLmFree, but advances p
    6572static inline void pLmFree(poly *p)   {p_LmFree(p, currRing);}
    66 // assumes p != NULL, deletes p, returns pNext(p)
     73/// assumes p != NULL, deletes p, returns pNext(p)
    6774#define pLmFreeAndNext(p) p_LmFreeAndNext(p, currRing)
    68 // assume p != NULL, deletes Lm(p)->coef and Lm(p)
     75/// assume p != NULL, deletes Lm(p)->coef and Lm(p)
    6976#define pLmDelete(p)    p_LmDelete(p, currRing)
    70 // like pLmDelete, returns pNext(p)
     77/// like pLmDelete, returns pNext(p)
    7178#define pLmDeleteAndNext(p) p_LmDeleteAndNext(p, currRing)
    7279
     
    8491#define pExpVectorDiff(pr, p1, p2)    p_ExpVectorDiff(pr, p1, p2, currRing)
    8592
    86 // Gets a copy of (resp. set) the exponent vector, where e is assumed
    87 // to point to (r->N +1)*sizeof(long) memory. Exponents are
    88 // filled in as follows: comp, e_1, .., e_n
     93/// Gets a copy of (resp. set) the exponent vector, where e is assumed
     94/// to point to (r->N +1)*sizeof(long) memory. Exponents are
     95/// filled in as follows: comp, e_1, .., e_n
    8996#define pGetExpV(p, e)      p_GetExpV(p, e, currRing)
    9097#define pSetExpV(p, e)      p_SetExpV(p, e, currRing)
     
    95102 *
    96103 ***************************************************************/
    97 // returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
     104/// returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
    98105#define pLmCmp(p,q)         p_LmCmp(p,q,currRing)
    99 // executes axtionE|actionG|actionS if p=q|p>q|p<q w.r.t monomial ordering
    100 // action should be a "goto ..."
     106/// executes axtionE|actionG|actionS if p=q|p>q|p<q w.r.t monomial ordering
     107/// action should be a "goto ..."
    101108#define pLmCmpAction(p,q, actionE, actionG, actionS)  \
    102109  _p_LmCmpAction(p,q,currRing, actionE, actionG,actionS)
     
    104111#define pLmEqual(p1, p2)     p_ExpVectorEqual(p1, p2, currRing)
    105112
    106 // pCmp: args may be NULL
    107 // returns: (p2==NULL ? 1 : (p1 == NULL ? -1 : p_LmCmp(p1, p2)))
     113/// pCmp: args may be NULL
     114/// returns: (p2==NULL ? 1 : (p1 == NULL ? -1 : p_LmCmp(p1, p2)))
    108115#define pCmp(p1, p2)    p_Cmp(p1, p2, currRing)
    109116
     
    115122 *
    116123 ***************************************************************/
    117 // returns TRUE, if leading monom of a divides leading monom of b
    118 // i.e., if there exists a expvector c > 0, s.t. b = a + c;
     124/// returns TRUE, if leading monom of a divides leading monom of b
     125/// i.e., if there exists a expvector c > 0, s.t. b = a + c;
    119126#define pDivisibleBy(a, b)  p_DivisibleBy(a,b,currRing)
    120 // like pDivisibleBy, except that it is assumed that a!=NULL, b!=NULL
     127/// like pDivisibleBy, except that it is assumed that a!=NULL, b!=NULL
    121128#define pLmDivisibleBy(a,b)  p_LmDivisibleBy(a,b,currRing)
    122 // like pLmDivisibleBy, does not check components
     129/// like pLmDivisibleBy, does not check components
    123130#define pLmDivisibleByNoComp(a, b) p_LmDivisibleByNoComp(a,b,currRing)
    124 // Divisibility tests based on Short Exponent vectors
    125 // sev_a     == pGetShortExpVector(a)
    126 // not_sev_b == ~ pGetShortExpVector(b)
     131/// Divisibility tests based on Short Exponent vectors
     132/// sev_a     == pGetShortExpVector(a)
     133/// not_sev_b == ~ pGetShortExpVector(b)
    127134#define pLmShortDivisibleBy(a, sev_a, b, not_sev_b) \
    128135  p_LmShortDivisibleBy(a, sev_a, b, not_sev_b, currRing)
    129136#define pLmRingShortDivisibleBy(a, sev_a, b, not_sev_b) \
    130137  p_LmRingShortDivisibleBy(a, sev_a, b, not_sev_b, currRing)
    131 // returns the "Short Exponent Vector" -- used to speed up divisibility
    132 // tests (see polys-impl.cc )
     138/// returns the "Short Exponent Vector" -- used to speed up divisibility
     139/// tests (see polys-impl.cc )
    133140#define pGetShortExpVector(a)   p_GetShortExpVector(a, currRing)
     141
    134142#ifdef HAVE_RINGS
    135 /* divisibility check over ground ring (which may contain zero divisors);
    136   TRUE iff LT(f) divides LT(g), i.e., LT(f)*c*m = LT(g), for some
    137   coefficient c and some monomial m;
    138   does not take components into account */
     143/// divisibility check over ground ring (which may contain zero divisors);
     144/// TRUE iff LT(f) divides LT(g), i.e., LT(f)*c*m = LT(g), for some
     145/// coefficient c and some monomial m;
     146/// does not take components into account */
    139147#define  pDivisibleByRingCase(f,g) p_DivisibleByRingCase(f,g,currRing)
    140148#endif
     
    145153 *
    146154 ***************************************************************/
    147 // return a copy of the poly
     155/// return a copy of the poly
    148156#define pCopy(p) p_Copy(p, currRing)
    149157#define pDelete(p_ptr)  p_Delete(p_ptr, currRing)
     
    177185 *
    178186 *************************************************************************/
    179 // sorts p, assumes all monomials in p are different
     187/// sorts p, assumes all monomials in p are different
    180188#define pSortMerger(p)          p_SortMerge(p, currRing)
    181189#define pSort(p)                p_SortMerge(p, currRing)
    182190
    183 // sorts p, p may have equal monomials
     191/// sorts p, p may have equal monomials
    184192#define pSortAdd(p)             p_SortAdd(p, currRing)
    185193
    186194
    187 // Assume: If considerd only as poly in any component of p
    188 // (say, monomials of other components of p are set to 0),
    189 // then p is already sorted correctly
     195/// Assume: If considerd only as poly in any component of p
     196/// (say, monomials of other components of p are set to 0),
     197/// then p is already sorted correctly
    190198#define pSortCompCorrect(p) pSort(p)
    191199
     
    195203 *
    196204 ***************************************************************/
    197 // return true if all p is eihter NULL, or if all exponents
    198 // of p are 0 and Comp of p is zero
     205/// return true if all p is eihter NULL, or if all exponents
     206/// of p are 0 and Comp of p is zero
    199207#define   pIsConstantComp(p)        p_IsConstantComp(p, currRing)
    200 // like above, except that Comp might be != 0
     208/// like above, except that Comp might be != 0
    201209#define   pIsConstant(p)            p_IsConstant(p,currRing)
    202 // return true if the Lm is a constant <>0
     210/// return true if the Lm is a constant <>0
    203211#define   pIsUnit(p)            p_IsUnit(p,currRing)
    204 // like above, except that p must be != NULL
     212/// like above, except that p must be != NULL
    205213#define   pLmIsConstantComp(p)      p_LmIsConstantComp(p, currRing)
    206214#define   pLmIsConstant(p)          p_LmIsConstant(p,currRing)
    207215
    208 // return TRUE if all monomials of p are constant
     216/// return TRUE if all monomials of p are constant
    209217#define   pIsConstantPoly(p)        p_IsConstantPoly(p, currRing)
    210218
     
    232240/*-----------the ordering of monomials:-------------*/
    233241#define pSetm(p)    p_Setm(p, currRing)
    234 // TODO:
     242/// TODO:
    235243#define pSetmComp(p)   p_Setm(p, currRing)
    236244
     
    252260#define pmInit(a,b) p_mInit(a,b,currRing)
    253261
    254 // ----------------- define to enable new p_procs -----*/
     262/* ----------------- define to enable new p_procs -----*/
    255263
    256264#define pDivide(a,b) p_Divide(a,b,currRing)
     
    282290
    283291
    284 // homogenizes p by multiplying certain powers of the varnum-th variable
     292/// homogenizes p by multiplying certain powers of the varnum-th variable
    285293#define  pHomogen(p,varnum) p_Homogen(p,varnum,currRing)
    286294
     
    297305#define   pTakeOutComp1(p,k)    p_TakeOutComp1(p,k,currRing)
    298306
    299 // Splits *p into two polys: *q which consists of all monoms with
    300 // component == comp and *p of all other monoms *lq == pLength(*q)
    301 // On return all components pf *q == 0
     307/// Splits *p into two polys: *q which consists of all monoms with
     308/// component == comp and *p of all other monoms *lq == pLength(*q)
     309/// On return all components pf *q == 0
    302310inline void pTakeOutComp(poly *p, long comp, poly *q, int *lq, const ring R = currRing)
    303311{
     
    306314
    307315
    308 // This is something weird -- Don't use it, unless you know what you are doing
     316/// This is something weird -- Don't use it, unless you know what you are doing
    309317inline poly      pTakeOutComp(poly * p, int k, const ring R = currRing)
    310318{
     
    366374
    367375
    368 // returns the length of a polynomial (numbers of monomials)
    369 // respect syzComp
     376/// returns the length of a polynomial (numbers of monomials)
     377/// respect syzComp
    370378static inline poly pLast(poly a, int &length) { return p_Last (a, length, currRing); }
    371379static inline poly pLast(poly a) { int l; return pLast(a, l); }
  • libpolys/coeffs/bigintmat.h

    r62a54b r89f209  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /*
    5 * ABSTRACT: class bigintmat: matrices of number
    6 *
    7 * Matrices are stored as 1-dim c-arrays but interpreted 2-dim as matrices.
    8 * Both modes of addressing are supported, note however, that the 1-dim
    9 * adressing starts at 0, the 2-dim at 1.
    10 *
    11 * Matrices are meant to represent column modules, thus the default
    12 * operations are always by column.
    13 *
    14 * While basic operations are supported over any ring (coeff), some more
    15 * advanced ones require more special rings: eg. echelon forms, solving
    16 * of linear equations is only effective over principal ideal or even
    17 * Euclidean rings.
    18 *
    19 * Be careful with the get/set/view/rawset functions to understand which
    20 * arguments are copied/ deleted or only assigned.
    21 */
    22 
    234#ifndef BIGINTMAT_H
    245#define BIGINTMAT_H
     
    2910#include <coeffs/rmodulon.h>
    3011
    31 /// matrix of numbers
    32 /// NOTE: no reference counting!!!
     12/**
     13 * @class bigintmat bigintmat.h <coeffs/bigintmat.h>
     14 *
     15 * Matrices of numbers
     16 *
     17 * Matrices are stored as 1-dim c-arrays but interpreted 2-dim as matrices.
     18 * Both modes of addressing are supported, note however, that the 1-dim
     19 * adressing starts at 0, the 2-dim at 1.
     20 *
     21 * Matrices are meant to represent column modules, thus the default
     22 * operations are always by column.
     23 *
     24 * While basic operations are supported over any ring (coeff), some more
     25 * advanced ones require more special rings: eg. echelon forms, solving
     26 * of linear equations is only effective over principal ideal or even
     27 * Euclidean rings.
     28 *
     29 * Be careful with the get/set/view/rawset functions to understand which
     30 * arguments are copied/ deleted or only assigned.
     31 *
     32 * @Note: no reference counting here!
     33 */
    3334class bigintmat
    3435{
     
    208209    char * String();
    209210    ///IO: writes the matrix into the current internal string buffer which
    210     /// must be started/ allocated before (e.g. @StringSetS)
     211    /// must be started/ allocated before (e.g. @ref StringSetS)
    211212    void Write();
    212213    ///IO: simply prints the matrix to the current output (screen?)
    213214    void Print();
    214 /***
    215  * Returns a string as it would have been printed in the interpreter.
    216  * Used e.g. in print functions of various blackbox types.
    217  **/
     215
     216   /**
     217    * Returns a string as it would have been printed in the interpreter.
     218    * Used e.g. in print functions of various blackbox types.
     219    */
    218220    char * StringAsPrinted();
    219221    void pprint(int maxwid);
     
    225227    // !WICHTIG: Überall, wo eine number ÃŒbergeben wird, und damit gearbeitet wird, die coeffs mitÃŒbergeben und erst
    226228    // ÃŒberprÃŒfen, ob diese mit basecoeffs ÃŒbereinstimmen. Falls nein: Breche ab!
     229   
    227230    /// swap columns i and j
    228231    void swap(int i, int j);
     
    243246    void getColRange(int j, int no, bigintmat *a);
    244247
    245     void getrow(int i, bigintmat *a); // Schreibt i-te Zeile in Vektor (Matrix) a
    246     void setcol(int j, bigintmat *m); // Setzt j-te Spalte gleich ÃŒbergebenem Vektor (Matrix) m
    247     void setrow(int i, bigintmat *m); // Setzt i-te Zeile gleich ÃŒbergebenem Vektor (Matrix) m
     248    void getrow(int i, bigintmat *a); ///< Schreibt i-te Zeile in Vektor (Matrix) a
     249    void setcol(int j, bigintmat *m); ///< Setzt j-te Spalte gleich ÃŒbergebenem Vektor (Matrix) m
     250    void setrow(int i, bigintmat *m); ///< Setzt i-te Zeile gleich ÃŒbergebenem Vektor (Matrix) m
    248251
    249252    ///horizontally join the matrices, m <- m|a
     
    253256    void extendCols (int i);
    254257
    255     bool add(bigintmat *b); // Addiert zur Matrix die Matrix b dazu. Return false => an error occured
    256     bool sub(bigintmat *b); // Subtrahiert ...
    257     bool skalmult(number b, coeffs c); // Multipliziert zur Matrix den Skalar b hinzu
    258     bool addcol(int i, int j, number a, coeffs c); // addiert a-faches der j-ten Spalte zur i-ten dazu
    259     bool addrow(int i, int j, number a, coeffs c); // ... Zeile ...
    260     void colskalmult(int i, number a, coeffs c); // Multipliziert zur i-ten Spalte den Skalar a hinzu
    261     void rowskalmult(int i, number a, coeffs c); // ... Zeile ...
    262     void coltransform(int i, int j, number a, number b, number c, number d); //  transforms cols (i,j) using the 2x2 matrix ((a,b)(c,d)) (hopefully)
    263     void concatrow(bigintmat *a, bigintmat *b); // FÃŒgt zwei Matrixen untereinander/nebeneinander in gegebene Matrix ein, bzw spaltet gegebenen Matrix auf
     258    bool add(bigintmat *b); ///< Addiert zur Matrix die Matrix b dazu. Return false => an error occured
     259    bool sub(bigintmat *b); ///< Subtrahiert ...
     260    bool skalmult(number b, coeffs c); ///< Multipliziert zur Matrix den Skalar b hinzu
     261    bool addcol(int i, int j, number a, coeffs c); ///< addiert a-faches der j-ten Spalte zur i-ten dazu
     262    bool addrow(int i, int j, number a, coeffs c); ///< ... Zeile ...
     263    void colskalmult(int i, number a, coeffs c); ///< Multipliziert zur i-ten Spalte den Skalar a hinzu
     264    void rowskalmult(int i, number a, coeffs c); ///< ... Zeile ...
     265    void coltransform(int i, int j, number a, number b, number c, number d); ///<  transforms cols (i,j) using the 2x2 matrix ((a,b)(c,d)) (hopefully)
     266    void concatrow(bigintmat *a, bigintmat *b); ///< FÃŒgt zwei Matrixen untereinander/nebeneinander in gegebene Matrix ein, bzw spaltet gegebenen Matrix auf
    264267    void concatcol(bigintmat *a, bigintmat *b);
    265     void splitrow(bigintmat *a, bigintmat *b); // Speichert in Matrix a den oberen, in b den unteren Teil der Matrix, vorausgesetzt die Dimensionen stimmen ÃŒberein
    266     void splitcol(bigintmat *a, bigintmat *b); // ... linken ... rechten ...
    267     void splitcol(bigintmat *a, int i); // Speichert die ersten i Spalten als Teilmatrix in a
    268     void splitrow(bigintmat *a, int i); // ... Zeilen ...
    269     bool copy(bigintmat *b); // Kopiert EintrÀge von b auf Bigintmat
     268    void splitrow(bigintmat *a, bigintmat *b); ///< Speichert in Matrix a den oberen, in b den unteren Teil der Matrix, vorausgesetzt die Dimensionen stimmen ÃŒberein
     269    void splitcol(bigintmat *a, bigintmat *b); ///< ... linken ... rechten ...
     270    void splitcol(bigintmat *a, int i); ///< Speichert die ersten i Spalten als Teilmatrix in a
     271    void splitrow(bigintmat *a, int i); ///< ... Zeilen ...
     272    bool copy(bigintmat *b); ///< Kopiert EintrÀge von b auf Bigintmat
    270273    void copySubmatInto(bigintmat *, int sr, int sc, int nr, int nc, int tr, int tc);
    271     void one(); // Macht Matrix (Falls quadratisch) zu Einheitsmatrix
    272     int isOne(); // is matrix is identity
    273     void zero(); // Setzt alle EintrÀge auf 0
     274    void one(); ///< Macht Matrix (Falls quadratisch) zu Einheitsmatrix
     275    int isOne(); ///< is matrix is identity
     276    void zero(); ///< Setzt alle EintrÀge auf 0
    274277    int isZero();
    275278    int colIsZero(int i);
    276     bigintmat *elim(int i, int j); // Liefert Streichungsmatrix (i-te Zeile und j-te Spalte gestrichen) zurÃŒck
    277     number pseudoinv(bigintmat *a); // Speichert in Matrix a die Pseudoinverse, liefert den Nenner zurÃŒck
    278     number trace(); // the trace ....
    279     number det(); // det (via LaPlace in general, hnf for euc. rings)
    280     number hnfdet(); // det via HNF
     279    bigintmat *elim(int i, int j); ///< Liefert Streichungsmatrix (i-te Zeile und j-te Spalte gestrichen) zurÃŒck
     280    number pseudoinv(bigintmat *a); ///< Speichert in Matrix a die Pseudoinverse, liefert den Nenner zurÃŒck
     281    number trace(); ///< the trace ....
     282    number det(); ///< det (via LaPlace in general, hnf for euc. rings)
     283    number hnfdet(); ///< det via HNF
    281284    /// Primzahlen als long long int, mÃŒssen noch in number umgewandelt werden?
    282     void hnf(); // transforms INPLACE to HNF
    283     void howell(); //dito, but Howell form (only different for zero-divsors)
     285    void hnf(); ///< transforms INPLACE to HNF
     286    void howell(); ///<dito, but Howell form (only different for zero-divsors)
    284287    void swapMatrix(bigintmat * a);
    285     bigintmat * modhnf(number p, coeffs c); // computes HNF(this | p*I)
     288    bigintmat * modhnf(number p, coeffs c); ///< computes HNF(this | p*I)
    286289    bigintmat * modgauss(number p, coeffs c);
    287     void skaldiv(number b); // Macht Ganzzahldivision aller MatrixeintrÀge mit b
    288     void colskaldiv(int j, number b); // Macht Ganzzahldivision aller j-ten SpalteneintrÀge mit b
    289     void mod(number p, coeffs c); // Reduziert komplette Matrix modulo p
    290     bigintmat* inpmod(number p, coeffs c); // Liefert Kopie der Matrix zurÃŒck, allerdings im Ring Z modulo p
    291     number content(); //the content, the gcd of all entries. Only makes sense for Euclidean rings (or possibly constructive PIR)
    292     void simplifyContentDen(number *den); // ensures that Gcd(den, content)=1
    293     // enden hier wieder
     290    void skaldiv(number b); ///< Macht Ganzzahldivision aller MatrixeintrÀge mit b
     291    void colskaldiv(int j, number b); ///< Macht Ganzzahldivision aller j-ten SpalteneintrÀge mit b
     292    void mod(number p, coeffs c); ///< Reduziert komplette Matrix modulo p
     293    bigintmat* inpmod(number p, coeffs c); ///< Liefert Kopie der Matrix zurÃŒck, allerdings im Ring Z modulo p
     294    number content(); ///<the content, the gcd of all entries. Only makes sense for Euclidean rings (or possibly constructive PIR)
     295    void simplifyContentDen(number *den); ///< ensures that Gcd(den, content)=1
     296    ///< enden hier wieder
    294297};
    295298
     
    298301
    299302/// Matrix-Add/-Sub/-Mult so oder mit operator+/-/* ?
    300 /// NOTE: NULL as a result means an error (non-compatible matrices?)
     303/// @Note: NULL as a result means an error (non-compatible matrices?)
    301304bigintmat * bimAdd(bigintmat * a, bigintmat * b);
    302305bigintmat * bimAdd(bigintmat * a, int b);
     
    315318
    316319// Wieder von Kira, Jan, Marco
    317 bigintmat * bimChangeCoeff(bigintmat *a, coeffs cnew); // Liefert Kopier von Matrix a zurÃŒck, mit coeffs cnew statt den ursprÃŒnglichen
    318 void bimMult(bigintmat *a, bigintmat *b, bigintmat *c); // Multipliziert Matrix a und b und speichert Ergebnis in c
     320bigintmat * bimChangeCoeff(bigintmat *a, coeffs cnew); ///< Liefert Kopier von Matrix a zurÃŒck, mit coeffs cnew statt den ursprÃŒnglichen
     321void bimMult(bigintmat *a, bigintmat *b, bigintmat *c); ///< Multipliziert Matrix a und b und speichert Ergebnis in c
    319322
    320323///solve Ax=b*d. x needs to be pre-allocated to the same number of columns as b.
     
    334337void diagonalForm(bigintmat *a, bigintmat **b, bigintmat **c);
    335338
    336 #endif // #ifndef BIGINTMAT_H
     339#endif /* #ifndef BIGINTMAT_H */
  • libpolys/coeffs/coeffs.h

    r62a54b r89f209  
    1 /*!
    2  \file coeffs/coeffs.h Coeff. Rings and Fields (interface)
     1/*! \file coeffs/coeffs.h Coefficient rings, fields and other domains suitable for Singular polynomials
     2   
     3  The main interface for Singular coefficients: \ref coeffs is the main handler for Singular numbers
    34*/
    45/****************************************
     
    5758typedef struct ip_sring const *   const_ring;
    5859
     60/// @class coeffs coeffs.h coeffs/coeffs.h
     61///
     62/// The main handler for Singular numbers which are suitable for Singular polynomials.
     63///
     64/// With it one may implement a ring, a field, a domain etc.
     65///
    5966struct n_Procs_s;
    6067typedef struct  n_Procs_s  *coeffs;
Note: See TracChangeset for help on using the changeset viewer.