idealFunctionals Class Reference

Public Member Functions
	idealFunctionals (int blockSize, int numFuncs)
	~idealFunctionals ()
int	dimen () const
void	endofConstruction ()
void	map (ring source)
void	insertCols (int *divisors, int to)
void	insertCols (int *divisors, const fglmVector to)
fglmVector	addCols (const int var, int basisSize, const fglmVector v) const
fglmVector	multiply (const fglmVector v, int var) const

Private Member Functions
matHeader *	grow (int var)

Private Attributes
int	_block
int	_max
int	_size
int	_nfunc
int *	currentSize
matHeader **	func

Detailed Description

Definition at line 76 of file fglmzero.cc.

Constructor & Destructor Documentation

idealFunctionals()

idealFunctionals::idealFunctionals	(	int	blockSize,
		int	numFuncs
	)

Definition at line 100 of file fglmzero.cc.

{
    int k;
    _block= blockSize;
    _max= _block;
    _size= 0;
    _nfunc= numFuncs;
 
    currentSize= (int *)omAlloc0( _nfunc*sizeof( int ) );
    //for ( k= _nfunc-1; k >= 0; k-- )
    //    currentSize[k]= 0;
 
    func= (matHeader **)omAlloc( _nfunc*sizeof( matHeader * ) );
    for ( k= _nfunc-1; k >= 0; k-- )
        func[k]= (matHeader *)omAlloc( _max*sizeof( matHeader ) );
}

~idealFunctionals()

idealFunctionals::~idealFunctionals

(

)

Definition at line 117 of file fglmzero.cc.

{
    int k;
    int l;
    int row;
    matHeader * colp;
    matElem * elemp;
    for ( k= _nfunc-1; k >= 0; k-- ) {
        for ( l= _size-1, colp= func[k]; l >= 0; l--, colp++ ) {
            if ( ( colp->owner == TRUE ) && ( colp->size > 0 ) ) {
                for ( row= colp->size-1, elemp= colp->elems; row >= 0; row--, elemp++ )
                    nDelete( & elemp->elem );
                omFreeSize( (ADDRESS)colp->elems, colp->size*sizeof( matElem ) );
            }
        }
        omFreeSize( (ADDRESS)func[k], _max*sizeof( matHeader ) );
    }
    omFreeSize( (ADDRESS)func, _nfunc*sizeof( matHeader * ) );
    omFreeSize( (ADDRESS)currentSize, _nfunc*sizeof( int ) );
}

Member Function Documentation

addCols()

fglmVector idealFunctionals::addCols	(	const int	var,
		int	basisSize,
		const fglmVector	v
	)		const

Definition at line 243 of file fglmzero.cc.

{
    fglmVector result( basisSize );
    matHeader * colp;
    matElem * elemp;
    number factor, temp;
    int k, l;
    int vsize = v.size();
 
    fglmASSERT( currentSize[var-1]+1 >= vsize, "wrong v.size()" );
    for ( k= 1, colp= func[var-1]; k <= vsize; k++, colp++ ) {
        factor= v.getconstelem( k );
        if ( ! nIsZero( factor ) ) {
            for ( l= colp->size-1, elemp= colp->elems; l >= 0; l--, elemp++ ) {
                temp= nMult( factor, elemp->elem );
                number newelem= nAdd( result.getconstelem( elemp->row ), temp );
                nDelete( & temp );
                nNormalize( newelem );
                result.setelem( elemp->row, newelem );
            }
        }
    }
    return result;
}

dimen()

int idealFunctionals::dimen ( ) const

inline

Definition at line 90 of file fglmzero.cc.

{ fglmASSERT( _size>0, "called too early"); return _size; }

endofConstruction()

void idealFunctionals::endofConstruction

(

)

Definition at line 139 of file fglmzero.cc.

{
    _size= currentSize[0];
}

grow()

matHeader * idealFunctionals::grow ( int  var )

private

Definition at line 179 of file fglmzero.cc.

{
    if ( currentSize[var-1] == _max ) {
        int k;
        for ( k= _nfunc; k > 0; k-- )
            func[k-1]= (matHeader *)omReallocSize( func[k-1], _max*sizeof( matHeader ), (_max + _block)*sizeof( matHeader ) );
        _max+= _block;
    }
    currentSize[var-1]++;
    return func[var-1] + currentSize[var-1] - 1;
}

insertCols() [1/2]

void idealFunctionals::insertCols	(	int *	divisors,
		const fglmVector	to
	)

Definition at line 212 of file fglmzero.cc.

{
    // divisors runs from divisors[0]..divisors[size-1]
    fglmASSERT( 0 < divisors[0] && divisors[0] <= _nfunc, "wrong number of divisors" );
    int k, l;
    int numElems= to.numNonZeroElems();
    matElem * elems;
    matElem * elemp;
    BOOLEAN owner = TRUE;
    if ( numElems > 0 ) {
        elems= (matElem *)omAlloc( numElems * sizeof( matElem ) );
        for ( k= 1, l= 1, elemp= elems; k <= numElems; k++, elemp++ ) {
            while ( nIsZero( to.getconstelem(l) ) ) l++;
            elemp->row= l;
            elemp->elem= nCopy( to.getconstelem( l ) );
            l++; // hochzaehlen, damit wir nicht noch einmal die gleiche Stelle testen
        }
    }
    else
        elems= NULL;
    for ( k= divisors[0]; k > 0; k-- ) {
        fglmASSERT( 0 < divisors[k] && divisors[k] <= _nfunc, "wrong divisor" );
        matHeader * colp = grow( divisors[k] );
        colp->size= numElems;
        colp->elems= elems;
        colp->owner= owner;
        owner= FALSE;
    }
}

insertCols() [2/2]

void idealFunctionals::insertCols	(	int *	divisors,
		int	to
	)

Definition at line 192 of file fglmzero.cc.

{
    fglmASSERT( 0 < divisors[0] && divisors[0] <= _nfunc, "wrong number of divisors" );
    int k;
    BOOLEAN owner = TRUE;
    matElem * elems = (matElem *)omAlloc( sizeof( matElem ) );
    elems->row= to;
    elems->elem= nInit( 1 );
    for ( k= divisors[0]; k > 0; k-- ) {
        fglmASSERT( 0 < divisors[k] && divisors[k] <= _nfunc, "wrong divisor" );
        matHeader * colp = grow( divisors[k] );
        colp->size= 1;
        colp->elems= elems;
        colp->owner= owner;
        owner= FALSE;
    }
}

map()

void idealFunctionals::map

(

ring

source

)

Definition at line 145 of file fglmzero.cc.

{
    // maps from ring source to currentRing.
    int var, col, row;
    matHeader * colp;
    matElem * elemp;
    number newelem;
 
    int * perm = (int *)omAlloc0( (_nfunc+1)*sizeof( int ) );
    maFindPerm( source->names, source->N, NULL, 0, currRing->names,
                currRing->N, NULL, 0, perm, NULL , currRing->cf->type);
    nMapFunc nMap=n_SetMap( source->cf, currRing->cf);
 
    matHeader ** temp = (matHeader **)omAlloc( _nfunc*sizeof( matHeader * ));
    for ( var= 0; var < _nfunc; var ++ ) {
        for ( col= 0, colp= func[var]; col < _size; col++, colp++ ) {
            if ( colp->owner == TRUE ) {
                for ( row= colp->size-1, elemp= colp->elems; row >= 0;
                  row--, elemp++ )
                {
                    newelem= nMap( elemp->elem, source->cf, currRing->cf );
                    nDelete( & elemp->elem );
                    elemp->elem= newelem;
                }
            }
        }
        temp[ perm[var+1]-1 ]= func[var];
    }
    omFreeSize( (ADDRESS)func, _nfunc*sizeof( matHeader * ) );
    omFreeSize( (ADDRESS)perm, (_nfunc+1)*sizeof( int ) );
    func= temp;
}

multiply()

fglmVector idealFunctionals::multiply	(	const fglmVector	v,
		int	var
	)		const

Definition at line 269 of file fglmzero.cc.

{
    fglmASSERT( v.size() == _size, "multiply: v has wrong size");
    fglmVector result( _size );
    matHeader * colp;
    matElem * elemp;
    number factor, temp;
    int k, l;
    for ( k= 1, colp= func[var-1]; k <= _size; k++, colp++ ) {
        factor= v.getconstelem( k );
        if ( ! nIsZero( factor ) ) {
            for ( l= colp->size-1, elemp= colp->elems; l >= 0; l--, elemp++ ) {
                temp= nMult( factor, elemp->elem );
                number newelem= nAdd( result.getconstelem( elemp->row ), temp );
                nDelete( & temp );
                nNormalize( newelem );
                result.setelem( elemp->row, newelem );
            }
        }
    }
    return result;
}

Field Documentation

_block

int idealFunctionals::_block

private

Definition at line 79 of file fglmzero.cc.

_max

int idealFunctionals::_max

private

Definition at line 80 of file fglmzero.cc.

_nfunc

int idealFunctionals::_nfunc

private

Definition at line 82 of file fglmzero.cc.

_size

int idealFunctionals::_size

private

Definition at line 81 of file fglmzero.cc.

currentSize

int* idealFunctionals::currentSize

private

Definition at line 83 of file fglmzero.cc.

func

matHeader** idealFunctionals::func

private

Definition at line 84 of file fglmzero.cc.

---

The documentation for this class was generated from the following file:

• kernel/fglm/fglmzero.cc