Changeset a642c64 in git


Ignore:
Timestamp:
Apr 30, 2010, 4:10:10 PM (13 years ago)
Author:
Christian Eder <ederc@…>
Branches:
(u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')
Children:
88e67079e82b521877fc5e0cb96a457cd3b458dc
Parents:
6ce7579378e276236fc3dfffd7b704449b1e306a
git-author:
Christian Eder <ederc@wawa.mathematik.uni-kl.de>2010-04-30 16:10:10+02:00
git-committer:
Mohamed Barakat <mohamed.barakat@rwth-aachen.de>2011-11-09 11:50:24+01:00
Message:
done changes in longrat* and added utils.h for is_max()
Files:
6 added
4 edited

Legend:

Unmodified
Added
Removed

  • coeffs/config.h.in

    r6ce757 ra642c64  
     1#define assume(x) ((void) 0)
     2#define memcpy4 memcpy

  • coeffs/longrat.cc

    r6ce757 ra642c64  
    4646#include <float.h>
    4747#include "coeffs.h"
     48#include "output.h"
    4849#include "omalloc.h"
    4950#include "numbers.h"
    … …  
    139140#endif
    140141
    141 static ring nlMapRing;
    142 static number nlMapP(number from)
     142static coeffs nlMapRing;
     143static number nlMapP(number from, const coeffs r)
    143144{
    144145  number to;
    145   to = nlInit(npInt(from,nlMapRing), currRing);
     146  to = nlInit(npInt(from,nlMapRing), r);
    146147  return to;
    147148}
    148149
    149 static number nlMapLongR(number from);
    150 static number nlMapR(number from);
     150static number nlMapLongR(number from, const coeffs r);
     151static number nlMapR(number from, const coeffs r);
    151152
    152153#ifdef HAVE_RINGS
    … …  
    183184#endif
    184185
    185 nMapFunc nlSetMap(const ring src, const ring dst)
     186nMapFunc nlSetMap(const coeffs src, const coeffs dst)
    186187{
    187188  if (rField_is_Q(src))
    … …  
    296297number nlRInit (long i);
    297298
    298 static number nlMapR(number from)
     299static number nlMapR(number from, const coeffs r)
    299300{
    300301  double f=nrFloat(from);
    … …  
    315316    i++;
    316317  }
    317   number r=nlRInit(1);
    318   mpz_set_d(r->z,f);
    319   memcpy(&(r->n),&h1,sizeof(h1));
    320   r->s=0; /* not normalized */
    321   if(f_sign==-1) r=nlNeg(r);
    322   nlNormalize(r);
    323   return r;
    324 }
    325 
    326 static number nlMapLongR(number from)
     318  number re=nlRInit(1);
     319  mpz_set_d(&(re->z),f);
     320  memcpy(&(re->n),&h1,sizeof(h1));
     321  re->s=0; /* not normalized */
     322  if(f_sign==-1) re=nlNeg(re,r);
     323  nlNormalize(re,r);
     324  return re;
     325}
     326
     327static number nlMapLongR(number from, const coeffs r)
    327328{
    328329  gmp_float *ff=(gmp_float*)from;
    … …  
    389390
    390391  if (res->s==0)
    391     nlNormalize(res);
    392   else
     392    nlNormalize(res,r);
     393  else if (mpz_size1(&res->z)<=MP_SMALL)
    393394  {
    394395    // res is new, res->ref is 1
    … …  
    464465//}
    465466
    466 int nlSize(number a)
     467int nlSize(number a, const coeffs r)
    467468{
    468469  if (a==INT_TO_SR(0))
    … …  
    493494* convert number to int
    494495*/
    495 int nlInt(number &i, const ring r)
     496int nlInt(number &i, const coeffs r)
    496497{
    497498  nlTest(i);
    498   nlNormalize(i);
     499  nlNormalize(i,r);
    499500  if (SR_HDL(i) &SR_INT) return SR_TO_INT(i);
    500501  if (i->s==3)
    … …  
    522523* convert number to bigint
    523524*/
    524 number nlBigInt(number &i)
     525number nlBigInt(number &i, const coeffs r)
    525526{
    526527  nlTest(i);
    527   nlNormalize(i);
     528  nlNormalize(i,r);
    528529  if (SR_HDL(i) &SR_INT) return (i);
    529530  if (i->s==3)
    530531  {
    531     return nlCopy(i);
     532    return nlCopy(i,r);
    532533  }
    533534  number tmp=nlRInit(1);
    … …  
    540541* 1/a
    541542*/
    542 number nlInvers(number a)
     543number nlInvers(number a, const coeffs r)
    543544{
    544545  nlTest(a);
    … …  
    550551      return a;
    551552    }
    552     if (nlIsZero(a))
     553    if (nlIsZero(a,r))
    553554    {
    554555      WerrorS(nDivBy0);
    … …  
    736737* u := a mod b in Z, u>=0
    737738*/
    738 number nlIntMod (number a, number b)
     739number nlIntMod (number a, number b, const coeffs r)
    739740{
    740741  if (b==INT_TO_SR(0))
    … …  
    777778    {
    778779      if (mpz_isNeg(b->z))
    779         return nlSub(a,b);
     780        return nlSub(a,b,r);
    780781      /*else*/
    781         return nlAdd(a,b);
     782        return nlAdd(a,b,r);
    782783    }
    783784    /*else*/
    … …  
    820821* u := a / b
    821822*/
    822 number nlDiv (number a, number b)
     823number nlDiv (number a, number b, const coeffs r)
    823824{
    824825  number u;
    825   if (nlIsZero(b))
     826  if (nlIsZero(b,r))
    826827  {
    827828    WerrorS(nDivBy0);
    … …  
    926927* u:= x ^ exp
    927928*/
    928 void nlPower (number x,int exp,number * u)
     929void nlPower (number x,int exp,number * u, const coeffs r)
    929930{
    930931  *u = INT_TO_SR(0); // 0^e, e!=0
    931   if (!nlIsZero(x))
     932  if (!nlIsZero(x,r))
    932933  {
    933934    nlTest(x);
    … …  
    939940    }
    940941    else if (x->s==0)
    941       nlNormalize(x);
     942      nlNormalize(x,r);
    942943    *u=ALLOC_RNUMBER();
    943944#if defined(LDEBUG)
    … …  
    989990* a > b ?
    990991*/
    991 BOOLEAN nlGreater (number a, number b)
     992BOOLEAN nlGreater (number a, number b, const coeffs r)
    992993{
    993994  nlTest(a);
    994995  nlTest(b);
    995   number r;
     996  number re;
    996997  BOOLEAN rr;
    997   r=nlSub(a,b);
    998   rr=(!nlIsZero(r)) && (nlGreaterZero(r));
    999   nlDelete(&r,currRing);
     998  re=nlSub(a,b,r);
     999  rr=(!nlIsZero(re,r)) && (nlGreaterZero(re,r));
     1000  nlDelete(&re,r);
    10001001  return rr;
    10011002}
    … …  
    10181019* result =gcd(a,b)
    10191020*/
    1020 number nlGcd(number a, number b, const ring r)
     1021number nlGcd(number a, number b, const coeffs r)
    10211022{
    10221023  number result;
    … …  
    10291030    return INT_TO_SR(1L);
    10301031  if (a==INT_TO_SR(0)) /* gcd(0,b) ->b */
    1031     return nlCopy(b);
     1032    return nlCopy(b,r);
    10321033  if (b==INT_TO_SR(0)) /* gcd(a,0) -> a */
    1033     return nlCopy(a);
     1034    return nlCopy(a,r);
    10341035  if (SR_HDL(a) & SR_HDL(b) & SR_INT)
    10351036  {
    … …  
    11131114* simplify x
    11141115*/
    1115 void nlNormalize (number &x)
     1116void nlNormalize (number &x, const coeffs r)
    11161117{
    11171118  if ((SR_HDL(x) & SR_INT) ||(x==NULL))
    … …  
    11621163* returns in result->z the lcm(a->z,b->n)
    11631164*/
    1164 number nlLcm(number a, number b, const ring r)
     1165number nlLcm(number a, number b, const coeffs r)
    11651166{
    11661167  number result;
    … …  
    11711172  {
    11721173    // b is 1/(b->n) => b->n is 1 => result is a
    1173     return nlCopy(a);
     1174    return nlCopy(a,r);
    11741175  }
    11751176  result=ALLOC_RNUMBER();
    … …  
    12071208}
    12081209
    1209 int nlModP(number n, int p)
     1210int nlModP(number n, int p, const coeffs r)
    12101211{
    12111212  if (SR_HDL(n) & SR_INT)
    … …  
    12211222    #ifdef NV_OPS
    12221223    if (npPrimeM>NV_MAX_PRIME)
    1223     return (int)((long)nvDiv((number)iz,(number)in));
     1224    return (int)((long)nvDiv((number)iz,(number)in,(const coeffs)r));
    12241225    #endif
    1225     return (int)((long)npDiv((number)iz,(number)in));
     1226    return (int)((long)npDiv((number)iz,(number)in,(const coeffs)r));
    12261227  }
    12271228  return iz;
    … …  
    12531254* acces to denominator, other 1 for integers
    12541255*/
    1255 number   nlGetDenom(number &n, const ring r)
     1256number   nlGetDenom(number &n, const coeffs r)
    12561257{
    12571258  if (!(SR_HDL(n) & SR_INT))
    … …  
    12591260    if (n->s==0)
    12601261    {
    1261       nlNormalize(n);
     1262      nlNormalize(n,r);
    12621263    }
    12631264    if (!(SR_HDL(n) & SR_INT))
    … …  
    12821283* acces to Nominator, nlCopy(n) for integers
    12831284*/
    1284 number   nlGetNumerator(number &n, const ring r)
     1285number   nlGetNumerator(number &n, const coeffs r)
    12851286{
    12861287  if (!(SR_HDL(n) & SR_INT))
    … …  
    12881289    if (n->s==0)
    12891290    {
    1290       nlNormalize(n);
     1291      nlNormalize(n,r);
    12911292    }
    12921293    if (!(SR_HDL(n) & SR_INT))
    … …  
    19381939* z := i/j
    19391940*/
    1940 number nlInit2 (int i, int j)
     1941number nlInit2 (int i, int j, const coeffs r)
    19411942{
    19421943  number z=ALLOC_RNUMBER();
    … …  
    19471948  mpz_init_set_si(z->n,(long)j);
    19481949  z->s = 0;
    1949   nlNormalize(z);
     1950  nlNormalize(z,r);
    19501951  return z;
    19511952}
    19521953
    1953 number nlInit2gmp (mpz_t i, mpz_t j)
     1954number nlInit2gmp (mpz_t i, mpz_t j, const coeffs r)
    19541955{
    19551956  number z=ALLOC_RNUMBER();
    … …  
    19601961  mpz_init_set(z->n,j);
    19611962  z->s = 0;
    1962   nlNormalize(z);
     1963  nlNormalize(z,r);
    19631964  return z;
    19641965}
    … …  
    20002001
    20012002
    2002 LINLINE number nlInit (int i, const ring r)
     2003LINLINE number nlInit (int i, const coeffs r)
    20032004{
    20042005  number n;
    … …  
    20232024}
    20242025
    2025 LINLINE BOOLEAN nlIsZero (number a)
     2026LINLINE BOOLEAN nlIsZero (number a, const coeffs r)
    20262027{
    20272028  return (a==INT_TO_SR(0));
    … …  
    20322033* copy a to b
    20332034*/
    2034 LINLINE number nlCopy(number a)
     2035LINLINE number nlCopy(number a, const coeffs r)
    20352036{
    20362037  if ((SR_HDL(a) & SR_INT)||(a==NULL))
    … …  
    20452046* delete a
    20462047*/
    2047 LINLINE void nlDelete (number * a, const ring r)
     2048LINLINE void nlDelete (number * a, const coeffs r)
    20482049{
    20492050  if (*a!=NULL)
    … …  
    20612062* za:= - za
    20622063*/
    2063 LINLINE number nlNeg (number a)
     2064LINLINE number nlNeg (number a, const coeffs r)
    20642065{
    20652066  nlTest(a);
    … …  
    20772078* u:= a + b
    20782079*/
    2079 LINLINE number nlAdd (number a, number b)
     2080LINLINE number nlAdd (number a, number b, const coeffs r)
    20802081{
    20812082  number u;
    … …  
    20942095number nlShort3_noinline(number x);
    20952096
    2096 LINLINE number nlInpAdd (number a, number b, const ring r)
     2097LINLINE number nlInpAdd (number a, number b, const coeffs r)
    20972098{
    20982099  if (SR_HDL(a) & SR_HDL(b) & SR_INT)
    … …  
    22452246}
    22462247
    2247 LINLINE number nlMult (number a, number b)
     2248LINLINE number nlMult (number a, number b, const coeffs r)
    22482249{
    22492250  nlTest(a);
    … …  
    22702271* u:= a - b
    22712272*/
    2272 LINLINE number nlSub (number a, number b)
     2273LINLINE number nlSub (number a, number b, const coeffs r)
    22732274{
    22742275  if (SR_HDL(a) & SR_HDL(b) & SR_INT)
    … …  
    22852286}
    22862287
    2287 LINLINE void nlInpMult(number &a, number b, const ring r)
     2288LINLINE void nlInpMult(number &a, number b, const coeffs r)
    22882289{
    22892290  number aa=a;
    22902291  if (((SR_HDL(b)|SR_HDL(aa))&SR_INT))
    22912292  {
    2292     number n=nlMult(aa,b);
     2293    number n=nlMult(aa,b,r);
    22932294    nlDelete(&a,r);
    22942295    a=n;
    … …  
    23192320#ifndef P_NUMBERS_H
    23202321
    2321 void nlInpGcd(number &a, number b, const ring r)
     2322void nlInpGcd(number &a, number b, const coeffs r)
    23222323{
    23232324  if ((SR_HDL(b)|SR_HDL(a))&SR_INT)
    … …  
    23332334  }
    23342335}
    2335 void nlInpIntDiv(number &a, number b, const ring r)
     2336void nlInpIntDiv(number &a, number b, const coeffs r)
    23362337{
    23372338  if ((SR_HDL(b)|SR_HDL(a))&SR_INT)
    … …  
    23722373}
    23732374
    2374 number nlFarey(number nN, number nP)
     2375number nlFarey(number nN, number nP, const coeffs r)
    23752376{
    23762377  mpz_t tmp; mpz_init(tmp);
    … …  
    24072408       mpz_init_set(z->n,B);
    24082409       z->s = 0;
    2409        nlNormalize(z);
     2410       nlNormalize(z,r);
    24102411       break;
    24112412    }

  • coeffs/longrat.h

    r6ce757 ra642c64  
    99*/
    1010#include "coeffs.h"
    11 
     11#include "config.h"
    1212#include "si_gmp.h"
    1313
    … …  
    5151LINLINE BOOLEAN  nlIsOne(number a, const coeffs r);
    5252LINLINE BOOLEAN  nlIsZero(number za, const coeffs r);
    53 LINLINE number   nlCopy(number a);
     53LINLINE number   nlCopy(number a, const coeffs r);
    5454LINLINE number   nl_Copy(number a, const coeffs r);
    5555LINLINE void     nlDelete(number *a, const coeffs r);
    … …  
    5959LINLINE number   nlMult(number a, number b, const coeffs r);
    6060
    61 number   nlInit2 (int i, int j);
     61number   nlInit2 (int i, int j, const coeffs r);
    6262number   nlInit2gmp (mpz_t i, mpz_t j);
    6363number   nlGcd(number a, number b, const coeffs r);

  • coeffs/longrat0.cc

    r6ce757 ra642c64  
    1010#include <stdio.h>
    1111#include <string.h>
     12#include "output.h"
    1213#include "config.h"
    1314#include "coeffs.h"
     15#include "utils.h"
    1416#include "omalloc.h"
    15 #include "output.h"
    1617#include "longrat.h"
    1718#include "numbers.h"
    … …  
    9899    {
    99100      number aa=*a;
    100       nlNormalize(aa);
     101      nlNormalize(aa,r);
    101102      *a=aa;
    102103    }
Note: See TracChangeset for help on using the changeset viewer.