Definition at line 2275 of file sparsmat.cc.
◆ sparse_number_mat()
sparse_number_mat::sparse_number_mat |
( |
ideal |
smat, |
|
|
const ring |
R |
|
) |
| |
Definition at line 2351 of file sparsmat.cc.
2352{
2354 poly* pmat;
2356
2369 pmat = smat->m;
2371 {
2373 }
2376}
#define omFreeSize(addr, size)
#define omFreeBin(addr, bin)
STATIC_VAR omBin smnrec_bin
static smnumber sm_Poly2Smnumber(poly, const ring)
◆ ~sparse_number_mat()
sparse_number_mat::~sparse_number_mat |
( |
| ) |
|
◆ smAllDel()
void sparse_number_mat::smAllDel |
( |
| ) |
|
|
private |
Definition at line 2795 of file sparsmat.cc.
2796{
2799
2801 {
2805 }
2807 {
2811 }
2813 {
2815 {
2819 }
2820 }
2821}
static void sm_NumberDelete(smnumber *, const ring R)
◆ smColToRow()
void sparse_number_mat::smColToRow |
( |
| ) |
|
|
private |
Definition at line 2720 of file sparsmat.cc.
2721{
2724
2726 {
2728 c = c->n;
2732 }
2733}
◆ smGElim()
void sparse_number_mat::smGElim |
( |
| ) |
|
|
private |
Definition at line 2576 of file sparsmat.cc.
2577{
2583
2585 {
2587 return;
2588 }
2589 do
2590 {
2599 {
2601 {
2602 do
2603 {
2607 }
while (
b !=
NULL);
2608 break;
2609 }
2610 if (a->pos <
b->pos)
2611 {
2613 a = a->n;
2614 }
2615 else if (a->pos >
b->pos)
2616 {
2620 }
2621 else
2622 {
2628 {
2630 }
2631 else
2632 {
2633 a->m = ha;
2635 a = a->n;
2636 }
2638 }
2640 {
2642 break;
2643 }
2644 }
2647 }
while (r !=
NULL);
2649}
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of 'a' and 'b', i.e., a*b
static FORCE_INLINE number n_Add(number a, number b, const coeffs r)
return the sum of 'a' and 'b', i.e., a+b
static FORCE_INLINE number n_Invers(number a, const coeffs r)
return the multiplicative inverse of 'a'; raise an error if 'a' is not invertible
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff 'n' represents the zero element.
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
static smnumber smNumberCopy(smnumber)
◆ smIsSing()
int sparse_number_mat::smIsSing |
( |
| ) |
|
|
inline |
◆ smRealPivot()
void sparse_number_mat::smRealPivot |
( |
| ) |
|
|
private |
Definition at line 2525 of file sparsmat.cc.
2526{
2530
2533 {
2536 {
2539 {
2541 {
2545 ropt = a->pos;
2546 }
2547 }
2548 else
2549 {
2552 {
2556 ropt = a->pos;
2557 }
2559 }
2560 a = a->n;
2561 }
2562 }
2565 {
2569 }
2571}
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of 'n'
static FORCE_INLINE BOOLEAN n_GreaterZero(number n, const coeffs r)
ordered fields: TRUE iff 'n' is positive; in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2),...
static FORCE_INLINE number n_InpNeg(number n, const coeffs r)
in-place negation of n MUST BE USED: n = n_InpNeg(n) (no copy is returned)
static FORCE_INLINE BOOLEAN n_Greater(number a, number b, const coeffs r)
ordered fields: TRUE iff 'a' is larger than 'b'; in Z/pZ: TRUE iff la > lb, where la and lb are the l...
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
◆ smRes2Ideal()
ideal sparse_number_mat::smRes2Ideal |
( |
| ) |
|
Definition at line 2506 of file sparsmat.cc.
2507{
2510
2512 {
2515 }
2518}
ideal idInit(int idsize, int rank)
initialise an ideal / module
static poly sm_Smnumber2Poly(number, const ring)
◆ smRowToCol()
void sparse_number_mat::smRowToCol |
( |
| ) |
|
|
private |
Definition at line 2740 of file sparsmat.cc.
2741{
2744
2750 {
2753 {
2756 {
2758 r = r->n;
2761 break;
2762 }
2764 }
2765 }
2766}
◆ smSelectPR()
void sparse_number_mat::smSelectPR |
( |
| ) |
|
|
private |
Definition at line 2656 of file sparsmat.cc.
2657{
2661
2663 {
2666 else
2668 }
2671 {
2672 do
2673 {
2675 a = a->n;
2676 }
while (a->pos <
rpiv);
2678 }
2679 else
2684 {
2687 {
2689 {
2691 a = a->n;
2692 if ((a ==
NULL) || (a->pos >
rpiv))
2693 break;
2695 {
2700 break;
2701 }
2702 }
2703 }
2704 else if (a->pos ==
rpiv)
2705 {
2710 }
2711 }
2714}
void PrintS(const char *s)
◆ smSolv()
void sparse_number_mat::smSolv |
( |
| ) |
|
Definition at line 2429 of file sparsmat.cc.
2430{
2434
2438 {
2441 r = r->n;
2443 }
2446 {
2450 }
2453 {
2458 {
2461 {
2464 {
2469 }
2470 else
2472 }
2474 }
2476 {
2478 {
2482 {
2485 }
2486 else
2488 }
2489 }
2490 else
2493 {
2497 }
2499 }
2501}
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of 'a' and 'b', i.e., a/b; raises an error if 'b' is not invertible in r exceptio...
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of 'a' and 'b', i.e., a-b
const CanonicalForm int s
const CanonicalForm int const CFList const Variable & y
◆ smTriangular()
void sparse_number_mat::smTriangular |
( |
| ) |
|
Definition at line 2398 of file sparsmat.cc.
2399{
2402 if (
sing != 0)
return;
2404 {
2413 if (
sing != 0)
return;
2414 }
2424}
◆ smZeroToredElim()
void sparse_number_mat::smZeroToredElim |
( |
| ) |
|
|
private |
Definition at line 2773 of file sparsmat.cc.
2774{
2777
2779 {
2783 {
2786 return;
2787 }
2788 i--;
2789 }
2790}
◆ _R
ring sparse_number_mat::_R |
|
private |
◆ act
int sparse_number_mat::act |
|
private |
◆ crd
int sparse_number_mat::crd |
|
private |
◆ dumm
◆ m_act
◆ m_res
◆ m_row
◆ ncols
int sparse_number_mat::ncols |
|
private |
◆ nrows
int sparse_number_mat::nrows |
|
private |
◆ perm
int* sparse_number_mat::perm |
|
private |
◆ piv
◆ red
◆ rpiv
int sparse_number_mat::rpiv |
|
private |
◆ sing
int sparse_number_mat::sing |
|
private |
◆ sol
number* sparse_number_mat::sol |
|
private |
◆ tored
int sparse_number_mat::tored |
|
private |
◆ wcl
int * sparse_number_mat::wcl |
|
private |
◆ wrw
int* sparse_number_mat::wrw |
|
private |
The documentation for this class was generated from the following file: