Changeset 3aae0e in git


Ignore:
Timestamp:
May 3, 2010, 8:40:12 PM (13 years ago)
Author:
Oleksandr Motsak <motsak@…>
Branches:
(u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')
Children:
3de81d0751fbbbc4448d3fd2531c9a6166149a7c
Parents:
8e0242295b4d15e0888fcf82a2aee88da415872f
git-author:
Oleksandr Motsak <motsak@mathematik.uni-kl.de>2010-05-03 20:40:12+02:00
git-committer:
Mohamed Barakat <mohamed.barakat@rwth-aachen.de>2011-11-09 11:50:25+01:00
Message:
Finished shortfl. Notice: CopyMap change
Location:
coeffs
Files:
1 added
5 edited

Legend:

Unmodified
Added
Removed

  • coeffs/gnumpc.cc

    r8e0242 r3aae0e  
    2020
    2121
     22#include "shortfl.h"
     23
     24
    2225#ifdef LDEBUG
    2326// not yet implemented
    … …  
    3437#endif
    3538
    36 const n_coeffType ID = n_long_C;
     39static const n_coeffType ID = n_long_C;
    3740
    3841number ngcMapQ(number from, const coeffs r, const coeffs aRing)
    … …  
    6972  assume( getCoeffType(aRing) == n_R );
    7073
    71   union nf
    72   {
    73     float _f;
    74     number _n;
    75     nf(float f) {_f = f;}
    76     nf(number n) {_n = n;}
    77     float F() const {return _f;}
    78     number N() const {return _n;}
    79   };
    80 
    8174  if ( from != NULL )
    8275  {
    83     gmp_complex *res=new gmp_complex((double)nf(from).F());
     76    gmp_complex *res=new gmp_complex((double)nrFloat(from));
    8477    return (number)res;
    8578  }

  • coeffs/numbers.cc

    r8e0242 r3aae0e  
    2828#endif
    2929
     30#ifndef assume
     31#  define assume(a) if(!(a)){ Werror( "Assumption: is wrong: %s\n", #a ); };
     32#endif
     33
     34
    3035//static int characteristic = 0;
    3136extern int IsPrime(int p);
    … …  
    7984int ndSize(number a, const coeffs r) { return (int)n_IsZero(a,r)==FALSE; }
    8085
    81 number ndCopy(number a) { return a; }
    82 number nd_Copy(number a,const coeffs r) { return r->nCopy(a); }
     86number ndCopy(number a, const coeffs) { return a; }
     87number ndCopyMap(number a, const coeffs r, const coeffs aRing)
     88{
     89  assume( getCoeffType(r) == getCoeffType(aRing) );
     90  assume( nField_has_simple_Alloc(r) && nField_has_simple_Alloc(aRing) );
     91 
     92  return a;
     93}
     94
     95number nd_Copy(number a, const coeffs r) { return n_Copy(a, r); }
    8396
    8497#ifdef HAVE_RINGS

  • coeffs/numbers.h

    r8e0242 r3aae0e  
    6565number ndGcd(number a, number b, const coeffs);
    6666number ndCopy(number a, const coeffs r);
     67number ndCopyMap(number a, const coeffs r, const coeffs aRing);
     68
    6769void   ndInpMult(number &a, number b, const coeffs r);
    6870number ndInpAdd(number &a, number b, const coeffs r);

  • coeffs/shortfl.cc

    r8e0242 r3aae0e  
    88*/
    99
     10#include "shortfl.h"
     11
    1012#include <string.h>
    1113#include "coeffs.h"
    12 #include <mylimits.h>
    1314#include "output.h"
    1415#include "numbers.h"
    1516#include "longrat.h"
    1617#include "mpr_complex.h"
    17 #include "shortfl.h"
    18 
    19 static float nrEps = 1.0e-3;
     18
     19
     20#include <mylimits.h>
     21// #include "limits.h"
     22#define MAX_INT_VAL INT_MAX
     23
     24#ifndef assume
     25#  define assume(a) if(!(a)){ Werror( "Assumption: is wrong: %s\n", #a ); };
     26#endif
     27
     28
     29
     30static const n_coeffType ID = n_R;
     31
     32static const float nrEps = 1.0e-3;
     33
    2034union nf
    2135{
    2236  float _f;
    2337  number _n;
    24   nf(float f) {_f = f;}
    25   nf(number n) {_n = n;}
    26   float F() const {return _f;}
    27   number N() const {return _n;}
     38
     39  nf(float f): _f(f){};
     40
     41  nf(number n): _n(n){};
     42
     43  inline float F() const {return _f;}
     44  inline number N() const {return _n;}
    2845};
    2946
     47
     48
     49
    3050float nrFloat(number n)
    3151{
    … …  
    3353}
    3454
     55
    3556BOOLEAN nrGreaterZero (number k, const coeffs r)
    3657{
     58  assume( getCoeffType(r) == ID );
     59
    3760  return nf(k).F() >= 0.0;
    3861}
    … …  
    4063number nrMult (number a,number b, const coeffs r)
    4164{
     65  assume( getCoeffType(r) == ID );
     66
    4267  return nf(nf(a).F() * nf(b).F()).N();
    4368}
    … …  
    4671* create a number from int
    4772*/
    48 number nrInit (int i, const coeffs R)
    49 {
    50   float r = (float)i;
    51   return nf(nf(r).F()).N();
     73number nrInit (int i, const coeffs r)
     74{
     75  assume( getCoeffType(r) == ID );
     76
     77  float f = (float)i;
     78  return nf(nf(f).F()).N();
    5279}
    5380
    … …  
    5582* convert a number to int
    5683*/
    57 int nrInt(number &n, const coeffs R)
    58 {
     84int nrInt(number &n, const coeffs r)
     85{
     86  assume( getCoeffType(r) == ID );
     87
    5988  int i;
    60   float r = nf(n).F();
    61   if (((float)INT_MIN <= r) || ((float)MAX_INT_VAL >= r))
    62     i = (int)r;
     89  float f = nf(n).F();
     90  if (((float)INT_MIN <= f) || ((float)MAX_INT_VAL >= f))
     91    i = (int)f;
    6392  else
    6493    i = 0;
    … …  
    78107}
    79108
    80 number nrAdd (number a, number b, const coeffs R)
    81 {
     109number nrAdd (number a, number b, const coeffs r)
     110{
     111  assume( getCoeffType(r) == ID );
     112
    82113  float x = nf(a).F();
    83114  float y = nf(b).F();
    84   float r = x + y;
     115  float f = x + y;
    85116  if (x > 0.0)
    86117  {
    87118    if (y < 0.0)
    88119    {
    89       x = r / (x - y);
     120      x = f / (x - y);
    90121      if (x < 0.0)
    91122        x = -x;
    92123      if (x < nrEps)
    93         r = 0.0;
     124        f = 0.0;
    94125    }
    95126  }
    … …  
    98129    if (y > 0.0)
    99130    {
    100       x = r / (y - x);
     131      x = f / (y - x);
    101132      if (x < 0.0)
    102133        x = -x;
    103134      if (x < nrEps)
    104         r = 0.0;
    105     }
    106   }
    107   return nf(r).N();
    108 }
    109 
    110 number nrSub (number a, number b, const coeffs R)
    111 {
     135        f = 0.0;
     136    }
     137  }
     138  return nf(f).N();
     139}
     140
     141number nrSub (number a, number b, const coeffs r)
     142{
     143  assume( getCoeffType(r) == ID );
     144
    112145  float x = nf(a).F();
    113146  float y = nf(b).F();
    114   float r = x - y;
     147  float f = x - y;
    115148  if (x > 0.0)
    116149  {
    117150    if (y > 0.0)
    118151    {
    119       x = r / (x + y);
     152      x = f / (x + y);
    120153      if (x < 0.0)
    121154        x = -x;
    122155      if (x < nrEps)
    123         r = 0.0;
     156        f = 0.0;
    124157    }
    125158  }
    … …  
    128161    if (y < 0.0)
    129162    {
    130       x = r / (x + y);
     163      x = f / (x + y);
    131164      if (x < 0.0)
    132165        x = -x;
    133166      if (x < nrEps)
    134         r = 0.0;
    135     }
    136   }
    137   return nf(r).N();
     167        f = 0.0;
     168    }
     169  }
     170  return nf(f).N();
    138171}
    139172
    140173BOOLEAN nrIsZero (number  a, const coeffs r)
    141174{
     175  assume( getCoeffType(r) == ID );
     176
    142177  return (0.0 == nf(a).F());
    143178}
    … …  
    145180BOOLEAN nrIsOne (number a, const coeffs r)
    146181{
     182  assume( getCoeffType(r) == ID );
     183
    147184  float aa=nf(a).F()-1.0;
    148185  if (aa<0.0) aa=-aa;
    … …  
    152189BOOLEAN nrIsMOne (number a, const coeffs r)
    153190{
     191  assume( getCoeffType(r) == ID );
     192
    154193  float aa=nf(a).F()+1.0;
    155194  if (aa<0.0) aa=-aa;
    … …  
    159198number nrDiv (number a,number b, const coeffs r)
    160199{
     200  assume( getCoeffType(r) == ID );
     201
    161202  float n = nf(b).F();
    162203  if (n == 0.0)
    … …  
    171212number  nrInvers (number c, const coeffs r)
    172213{
     214  assume( getCoeffType(r) == ID );
     215
    173216  float n = nf(c).F();
    174217  if (n == 0.0)
    … …  
    182225number nrNeg (number c, const coeffs r)
    183226{
     227  assume( getCoeffType(r) == ID );
     228
    184229  return nf(-nf(c).F()).N();
    185230}
    … …  
    187232BOOLEAN nrGreater (number a,number b, const coeffs r)
    188233{
     234  assume( getCoeffType(r) == ID );
     235
    189236  return nf(a).F() > nf(b).F();
    190237}
    … …  
    192239BOOLEAN nrEqual (number a,number b, const coeffs r)
    193240{
     241  assume( getCoeffType(r) == ID );
     242
    194243  number x = nrSub(a,b,r);
    195244  return nf(x).F() == nf((float)0.0).F();
    … …  
    198247void nrWrite (number &a, const coeffs r)
    199248{
     249  assume( getCoeffType(r) == ID );
     250
    200251  StringAppend("%9.3e", nf(a).F());
    201252}
    … …  
    203254void nrPower (number a, int i, number * result, const coeffs r)
    204255{
     256  assume( getCoeffType(r) == ID );
     257
    205258  if (i==0)
    206259  {
    … …  
    217270}
    218271
     272namespace {
    219273static const char* nrEatr(const char *s, float *r)
    220274{
    … …  
    235289  return s;
    236290}
    237 
    238 const char *nIllegalChar="illegal character in number";
     291};
    239292
    240293const char * nrRead (const char *s, number *a, const coeffs r)
    241294{
     295
     296  assume( getCoeffType(r) == ID );
     297
     298  static const char *nIllegalChar="illegal character in number";
     299
    242300  const char *t;
    243301  const char *start=s;
    … …  
    294352}
    295353
    296 /*2
    297 * the last used charcteristic
    298 */
    299 int nrGetChar()
    300 {
    301   return 0;
    302 }
     354
     355// the last used charcteristic
     356// int nrGetChar(){ return 0; }
     357
    303358
    304359#ifdef LDEBUG
    … …  
    306361* test valid numbers: not implemented yet
    307362*/
    308 //BOOLEAN nrDBTest(number a, const char *f, const int l)
    309 //{
    310 //  return TRUE;
    311 //}
     363BOOLEAN  nrDBTest(number a, const char *f, const int l, const coeffs r);
     364{
     365  assume( getCoeffType(r) == ID );
     366
     367  return TRUE;
     368}
    312369#endif
    313370
     371static number nrMapP(number from, const coeffs r, const coeffs aRing)
     372{
     373  assume( getCoeffType(r) == ID );
     374  assume( getCoeffType(aRing) ==  n_Zp );
     375 
     376  int i = (int)((long)from);
     377  float f = (float)i;
     378  return nf(f).N();
     379}
     380
     381static number nrMapLongR(number from, const coeffs r, const coeffs aRing)
     382{
     383  assume( getCoeffType(r) == ID );
     384  assume( getCoeffType(aRing) == n_long_R );
     385
     386  float t =(float)mpf_get_d((mpf_srcptr)from);
     387  return nf(t).N();
     388}
     389
     390static number nrMapC(number from, const coeffs r, const coeffs aRing)
     391{ 
     392  assume( getCoeffType(r) == ID );
     393  assume( getCoeffType(aRing) == n_long_C );
     394 
     395  gmp_float h = ((gmp_complex*)from)->real();
     396  float t =(float)mpf_get_d((mpf_srcptr)&h);
     397  return nf(t).N();
     398}
     399
     400
     401number nrMapQ(number from, const coeffs r, const coeffs aRing)
     402{
    314403/* in longrat.h
    315404#define SR_INT    1
    … …  
    328417#define MPZ_CLEAR mpz_clear
    329418
    330 number nrMapQ(number from)
    331 {
     419  assume( getCoeffType(r) == ID );
     420  assume( getCoeffType(aRing) == n_Q );
     421
    332422  mpz_t h;
    333423  mpz_ptr g,z,n;
    … …  
    423513}
    424514
    425 static number nrMapP(number from, const coeffs R)
    426 {
    427   int i = (int)((long)from);
    428   float r = (float)i;
    429   return nf(r).N();
    430 }
    431 
    432 static number nrMapLongR(number from, const coeffs R)
    433 {
    434   float t =(float)mpf_get_d((mpf_srcptr)from);
    435   return nf(t).N();
    436 }
    437 static number nrMapC(number from, const coeffs r)
    438 {
    439   gmp_float h = ((gmp_complex*)from)->real();
    440   float t =(float)mpf_get_d((mpf_srcptr)&h);
    441   return nf(t).N();
    442 }
    443515
    444516nMapFunc nrSetMap(const coeffs src, const coeffs dst)
    445517{
     518  assume( getCoeffType(dst) == ID );
     519
    446520  if (nField_is_Q(src))
    447521  {
    … …  
    454528  if (nField_is_R(src))
    455529  {
    456     return ndCopy;
     530    return ndCopyMap;
    457531  }
    458532  if(nField_is_Zp(src))

  • coeffs/shortfl.h

    r8e0242 r3aae0e  
    2727void    nrWrite       (number &a, const coeffs r);
    2828const char *  nrRead  (const char *s, number *a, const coeffs r);
    29 int     nrGetChar();
    3029#ifdef LDEBUG
    31 BOOLEAN nrDBTest(number a, const coeffs, rconst char *f, const int l);
     30BOOLEAN nrDBTest(number a, const coeffs r, const char *f, const int l);
    3231#endif
    3332
     33/// Get a mapping function from src into the domain of this type: n_R
    3434nMapFunc nrSetMap(const coeffs src, const coeffs dst);
    3535
    36 float   nrFloat(number n);
    37 number nrMapQ(number from, const coeffs r);
     36// Where are the following used?
     37// int     nrGetChar();
     38// number nrMapQ(number from, const coeffs r, const coeffs aRing);
     39
     40
     41/// Converts a n_R number into a float. Needed by Maps
     42float   nrFloat(number n);
     43
    3844#endif
    3945
Note: See TracChangeset for help on using the changeset viewer.