source: git/libpolys/coeffs/OPAEp.cc @ ba5e9e

/****************************************
*  Computer Algebra System SINGULAR     *
****************************************/
/*
* Dense Polynomials modulo p
*/
//Schauen was hier ÃŒberhaupt sinn macht
#include "libpolysconfig.h"
#include <misc/auxiliary.h>

#ifdef HAVE_FACTORY
#include <factory/factory.h>
#endif

#include <string.h>
#include <omalloc/omalloc.h>
#include <coeffs/coeffs.h>
#include <reporter/reporter.h>
#include <coeffs/numbers.h>
#include <coeffs/longrat.h>
#include <coeffs/modulop.h>
#include <coeffs/mpr_complex.h>
#include <misc/mylimits.h>
#include <coeffs/OPAEp.h>
#include <coeffs/AEp.h>





// DEFINITION DER FUNKTIONEN

number  nAEpAdd(number a, number b,const coeffs r)
{
    p_poly* f=reinterpret_cast<p_poly*> (a);
    p_poly* g=reinterpret_cast<p_poly*> (b);
    p_poly *res=new p_poly;
    res->p_poly_set(*f);
    res->p_poly_add_to(*g);
    return (number) res;
}

number  nAEpMult(number a, number b,const coeffs r)
{
    p_poly* f=reinterpret_cast<p_poly*> (a);
    p_poly* g=reinterpret_cast<p_poly*> (b);
    p_poly *res=new p_poly;
    res->p_poly_set(*f);
    res->p_poly_mult_n_to(*g);
    return (number) res;
}

number  nAEpSub(number a, number b,const coeffs r)
{
    p_poly* f=reinterpret_cast<p_poly*> (a);
    p_poly* g=reinterpret_cast<p_poly*> (b);
    p_poly *res=new p_poly;
    res->p_poly_set(*f);
    res->p_poly_sub_to(*g);
    return (number) res;
}


number  nAEpDiv(number a, number b,const coeffs r)
{
    p_poly* f=reinterpret_cast<p_poly*> (a);
    p_poly* g=reinterpret_cast<p_poly*> (b);
    p_poly *res=new p_poly;
    p_poly *s=new p_poly;
    res->p_poly_set(*f);
    res->p_poly_div_to(*res,*s,*g);
    return (number) res;
}


number  nAEpIntDiv(number a, number b,const coeffs r)
{

    p_poly* f=reinterpret_cast<p_poly*> (a);
    mpz_t* i= reinterpret_cast<mpz_t*> (b);
    p_poly *res=new p_poly;
    res->p_poly_set(*f);
    res->p_poly_scalar_div_to(*i);
    return (number) res;
}

number  nAEpIntMod(number a, number b,const coeffs r)
{
    return a;
}

number  nAEpExactDiv(number a, number b,const coeffs r)
{
    p_poly* f=reinterpret_cast<p_poly*> (a);
    p_poly* g=reinterpret_cast<p_poly*> (b);
    p_poly *res=new p_poly;
    p_poly *s=new p_poly;
    res->p_poly_set(*f);
    res->p_poly_div_to(*res,*s,*g);
    return (number) res;
}



number nAEpInit(long i, const coeffs r)
{
    int j=7;
    mpz_t m;
    mpz_init_set_ui(m,i);
    p_poly* res=new p_poly;
    res->p_poly_set(m,j);
    number res1=reinterpret_cast<number>(res);
    return  res1;
}

number nAEpInitMPZ(mpz_t m, const coeffs r)
{
    int j=7;
    p_poly* res=new p_poly;
    res->p_poly_set(m,j);
    number res1=reinterpret_cast<number>(res);
    return  res1;

}

int nAEpSize (number a,const coeffs r)
{
    p_poly* f=reinterpret_cast<p_poly*> (a);
    return f->deg;
}

int nAEpInt(number &a,const coeffs r)
{
    return 1;
}


number nAEpMPZ(number a,const coeffs r)
{
    return a;
}


number nAEpNeg(number c, const coeffs r)
{
    p_poly* f=reinterpret_cast<p_poly*> (c);
    p_poly *res=new p_poly;
    res->p_poly_set(*f);
    res->p_poly_neg();
    return (number) res;
}

number nAEpCopy(number c, const coeffs r)
{
    return c;
}

number nAEpRePart(number c, const coeffs r)
{
    return c;
}

number nAEpImPart(number c, const coeffs r)
{
    return  c;
}

void    nAEpWriteLong   (number &a, const coeffs r)
{
    p_poly* f=reinterpret_cast <p_poly*>(a);
    f->p_poly_print();

    return;
}

void    nAEpWriteShort  (number &a, const coeffs r)
{
    p_poly* f=reinterpret_cast <p_poly*>(a);
    f->p_poly_print();
    return ;
}


const char *  nAEpRead  (const char *s, number *a,const coeffs r)
{
    p_poly& f=reinterpret_cast <p_poly&>(a);
    f.p_poly_insert();
    f.p_poly_print();
    *a=reinterpret_cast <number>(&f);
    char* c=new char;
    *c='c';
    return c;
}

number nAEpNormalize    (number a,number b,const coeffs r) // ?
{
    return a;
}

BOOLEAN nAEpGreater     (number a, number b,const coeffs r)
{
    p_poly* f=reinterpret_cast<p_poly*> (a);
    p_poly* g=reinterpret_cast<p_poly*> (b);
    if (f->deg > g->deg) {return FALSE;}
    else {return TRUE;}
}

BOOLEAN nAEpEqual     (number a, number b,const coeffs r)
{
    p_poly* f=reinterpret_cast<p_poly*> (a);
    p_poly* g=reinterpret_cast<p_poly*> (b);
    if (f->is_equal(*g) == 1) {return FALSE;}
    else {return TRUE;}
}

BOOLEAN nAEpIsZero      (number a,const coeffs r)
{
    p_poly* f=reinterpret_cast<p_poly*> (a);
    if (f->is_zero() == 1) {return FALSE;}
    else {return TRUE;}
}

BOOLEAN nAEpIsOne      (number a,const coeffs r)
{
    p_poly* f=reinterpret_cast<p_poly*> (a);
    if (f->is_one() == 1) {return FALSE;}
    else {return TRUE;}
}

BOOLEAN nAEpIsMOne      (number a,const coeffs r)
{
    number b=nAEpNeg(a,r);
    p_poly* f=reinterpret_cast<p_poly*> (b);
    if (f->is_one() == 1) {return FALSE;}
    else {return TRUE;}
}

BOOLEAN nAEpGreaterZero     (number a, const coeffs r)
{
    if (nAEpIsZero(a,r) == FALSE) { return TRUE; }
    else { return FALSE; }
}

void    nAEpPower       (number a, int i, number * result,const coeffs r)
{
    return;
}

number nAEpGetDenom      (number &a, const coeffs r)
{
    return (number) 1;
}

number nAEpGetNumerator      (number &a, const coeffs r)
{
    return a;
}

number nAEpGcd           (number a,number b,const coeffs r)
{
    p_poly* f=reinterpret_cast<p_poly*> (a);
    p_poly* g=reinterpret_cast<p_poly*> (b);
    p_poly *res=new p_poly;
    res->p_poly_gcd(*f,*g);
    return (number) res;
}

number nAEpLcm          (number a,number b,const coeffs r)
{
    p_poly* f=reinterpret_cast<p_poly*> (a);
    p_poly* g=reinterpret_cast<p_poly*> (b);
    p_poly *gcd=new p_poly;
    p_poly *res=new p_poly;
    p_poly *s=new p_poly;
    gcd->p_poly_gcd(*f,*g);
    res->p_poly_mult_n(*f,*g);
    res->p_poly_div_to(*res,*s,*gcd);
    return (number) res;
}

void    nAEpDelete       (number *a, const coeffs r)
{
    return;
}

/*
number    nAEpSetMap        (number a, const coeffs r)
{
        return a;
}
*/
char*    nAEpName       (number a, const coeffs r)
{
    char* c=new char;
    *c='c';

    return c;;
}

void    nAEpInpMult       (number &a, number b,const coeffs r)
{
    p_poly* f=reinterpret_cast<p_poly*> (a);
    p_poly* g=reinterpret_cast<p_poly*> (g);
    f->p_poly_mult_n_to(*g);
    a=(number) f;
    return ;
}

void    nAEpCoeffWrite   (const coeffs r, BOOLEAN details)
{
    return;
}

BOOLEAN nAEpClearContent  (number a,const coeffs r)
{
    return FALSE;
}

BOOLEAN nAEpClearDenominators  (number a,const coeffs r)
{
    return FALSE;
}



//INITIALISIERUNG FÜR SINGULAR


BOOLEAN n_pAEInitChar(coeffs r,void *p) // vlt noch void* p hin
{
    //Charakteristik abgreifen!
    const int c = (int) (long) p;


    r->ch=c;
    r->cfKillChar=NULL;
    r->nCoeffIsEqual=ndCoeffIsEqual;
    r->cfMult  = nAEpMult;
    r->cfSub   = nAEpSub;
    r->cfAdd   = nAEpAdd;
    r->cfDiv   = nAEpDiv;
    r->cfIntDiv= nAEpIntDiv;
    r->cfIntMod= nAEpIntMod;
    r->cfExactDiv= nAEpExactDiv;
    r->cfInit = nAEpInit;
    r->cfSize  = nAEpSize;
    r->cfInt  = nAEpInt;
#ifdef HAVE_RINGS
    //r->cfDivComp = NULL; // only for ring stuff
    //r->cfIsUnit = NULL; // only for ring stuff
    //r->cfGetUnit = NULL; // only for ring stuff
    //r->cfExtGcd = NULL; // only for ring stuff
    // r->cfDivBy = NULL; // only for ring stuff
#endif
    r->cfNeg   = nAEpNeg;
    r->cfInvers= NULL;
    //r->cfCopy  = ndCopy;
    //r->cfRePart = ndCopy;
    //r->cfImPart = ndReturn0;
    r->cfWriteLong = nAEpWriteLong;
    r->cfRead = nAEpRead;
    //r->cfNormalize=ndNormalize;
    r->cfGreater = nAEpGreater;
    r->cfEqual = nAEpEqual;
    r->cfIsZero = nAEpIsZero;
    r->cfIsOne = nAEpIsOne;
    r->cfIsMOne = nAEpIsOne;
    r->cfGreaterZero = nAEpGreaterZero;
    r->cfPower = nAEpPower; // ZU BEARBEITEN
    r->cfGetDenom = nAEpGetDenom;
    r->cfGetNumerator = nAEpGetNumerator;
    r->cfGcd  = nAEpGcd;
    r->cfLcm  = nAEpLcm; // ZU BEARBEITEN
    r->cfDelete= nAEpDelete;
    r->cfSetMap = npSetMap;
    r->cfName = nAEpName;
    r->cfInpMult=nAEpInpMult; //????
    r->cfInit_bigint= NULL; // nAEpMap0;
    r->cfCoeffWrite=nAEpCoeffWrite; //????


    // the variables:
    r->nNULL = (number) 0;
    //r->type = n_AE;
    r->ch = c;
    r->has_simple_Alloc=TRUE;
    r->has_simple_Inverse=TRUE;
    return FALSE;
}