Changeset 2b957a in git


Ignore:
Timestamp:
Jun 8, 2010, 11:40:27 PM (13 years ago)
Author:
Oleksandr Motsak <motsak@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', '0604212ebb110535022efecad887940825b97c3f')
Children:
c4c8181ff644b04ae3f3b82007442444a629e055
Parents:
c3d17527305d0cf9da8226a23b8fc95f6e3f37d0
git-author:
Oleksandr Motsak <motsak@mathematik.uni-kl.de>2010-06-08 23:40:27+02:00
git-committer:
Mohamed Barakat <mohamed.barakat@rwth-aachen.de>2011-11-09 11:55:03+01:00
Message:
Fixing bugs
Location:
coeffs
Files:
1 added
13 edited

Legend:

Unmodified
Added
Removed

  • coeffs/Makefile.in

    rc3d175 r2b957a  
    3535CXXTEMPLFLAGS   = -fno-implicit-templates --no-exceptions
    3636CPPFLAGS        = -I${srcdir} -I${includedir} -I${srcdir}/../misc/ -I${srcdir}/../resource/ -I${srcdir}/../output/ -L${srcdir}/../output/ -L${libdir} -lgmp
    37 DEFS            = -DNDEBUG -DOM_NDEBUG -Dix86_Linux -DHAVE_CONFIG_H
     37DEFS            = -Dix86_Linux -DHAVE_CONFIG_H -DLDEBUG -DDEBUG -DOM_DEBUG -DHAVE_ASSUME
     38
     39# -DNDEBUG -DOM_NDEBUG
    3840
    3941## End configuration dependend stuff
    … …  
    9294        $(INSTALL_DATA) coeffs.h $(includedir)/coeffs.h
    9395
    94 test: libcoeffs.a
     96test: test.cc libcoeffs.a
    9597        ${CXX} ${CXXFLAGS} ${CXXTEMPLFLAGS} ${CPPFLAGS} ${DEFS} test.cc -L. -I. -lcoeffs -o test -lomalloc -loutput

  • coeffs/gnumpc.cc

    rc3d175 r2b957a  
    375375
    376376
    377 static BOOLEAN ngcCoeffsEqual(const coeffs r, n_coeffType n, int)
     377static BOOLEAN ngcCoeffsEqual(const coeffs r, n_coeffType n, void*)
    378378{
    379379  assume( getCoeffType(r) == ID );
    … …  
    382382};
    383383
    384 void ngcInitChar(coeffs n, int)
     384void ngcInitChar(coeffs n, void*)
    385385{
    386386  assume( getCoeffType(n) == ID );

  • coeffs/gnumpc.h

    rc3d175 r2b957a  
    1414
    1515/// Initialize r
    16 void ngcInitChar(coeffs r, int);
     16void ngcInitChar(coeffs r, void*);
    1717
    1818/// test, whether r is an instance of nInitCoeffs(n, parameter) */
    19 static BOOLEAN ngcCoeffsEqual(const coeffs r, n_coeffType n, int parameter);
     19static BOOLEAN ngcCoeffsEqual(const coeffs r, n_coeffType n, void* parameter);
    2020
    2121

  • coeffs/longrat.cc

    rc3d175 r2b957a  
    191191
    192192#ifdef LDEBUG
    193 BOOLEAN nlDBTest(number a, const char *f,const int l)
     193BOOLEAN nlDBTest(number a, const char *f,const int l, const coeffs r)
    194194{
    195195  if (a==NULL)
    … …  
    376376    res=nlShort3(res);
    377377  }
    378   nlTest(res);
     378  nlTest(res, dst);
    379379  return res;
    380380}
    … …  
    476476int nlInt(number &i, const coeffs r)
    477477{
    478   nlTest(i);
     478  nlTest(i, r);
    479479  nlNormalize(i,r);
    480480  if (SR_HDL(i) &SR_INT) return SR_TO_INT(i);
    … …  
    505505number nlBigInt(number &i, const coeffs r)
    506506{
    507   nlTest(i);
     507  nlTest(i, r);
    508508  nlNormalize(i,r);
    509509  if (SR_HDL(i) &SR_INT) return (i);
    … …  
    523523number nlInvers(number a, const coeffs r)
    524524{
    525   nlTest(a);
     525  nlTest(a, r);
    526526  number n;
    527527  if (SR_HDL(a) & SR_INT)
    … …  
    551551      mpz_init_set_si(n->n,(long)-SR_TO_INT(a));
    552552    }
    553     nlTest(n);
     553    nlTest(n, r);
    554554    return n;
    555555  }
    … …  
    592592    }
    593593  }
    594   nlTest(n);
     594  nlTest(n, r);
    595595  return n;
    596596}
    … …  
    600600* u := a / b in Z, if b | a (else undefined)
    601601*/
    602 number   nlExactDiv(number a, number b)
     602number   nlExactDiv(number a, number b, const coeffs r)
    603603{
    604604  if (b==INT_TO_SR(0))
    … …  
    644644  }
    645645  u=nlShort3(u);
    646   nlTest(u);
     646  nlTest(u, r);
    647647  return u;
    648648}
    … …  
    651651* u := a / b in Z
    652652*/
    653 number nlIntDiv (number a, number b)
     653number nlIntDiv (number a, number b, const coeffs r)
    654654{
    655655  if (b==INT_TO_SR(0))
    … …  
    710710  }
    711711  u=nlShort3(u);
    712   nlTest(u);
     712  nlTest(u, r);
    713713  return u;
    714714}
    … …  
    794794  }
    795795  u=nlShort3(u);
    796   nlTest(u);
     796  nlTest(u, r);
    797797  return u;
    798798}
    … …  
    900900    u=nlShort3(u);
    901901  }
    902   nlTest(u);
     902  nlTest(u, r);
    903903  return u;
    904904}
    … …  
    912912  if (!nlIsZero(x,r))
    913913  {
    914     nlTest(x);
     914    nlTest(x, r);
    915915    number aa=NULL;
    916916    if (SR_HDL(x) & SR_INT)
    … …  
    952952#ifdef LDEBUG
    953953  if (exp<0) Print("nlPower: neg. exp. %d\n",exp);
    954   nlTest(*u);
     954  nlTest(*u, r);
    955955#endif
    956956}
    … …  
    960960* za >= 0 ?
    961961*/
    962 BOOLEAN nlGreaterZero (number a)
    963 {
    964   nlTest(a);
     962BOOLEAN nlGreaterZero (number a, const coeffs r)
     963{
     964  nlTest(a, r);
    965965  if (SR_HDL(a) & SR_INT) return SR_HDL(a)>1L /* represents number(0) */;
    966966  return (!mpz_isNeg(a->z));
    … …  
    972972BOOLEAN nlGreater (number a, number b, const coeffs r)
    973973{
    974   nlTest(a);
    975   nlTest(b);
     974  nlTest(a, r);
     975  nlTest(b, r);
    976976  number re;
    977977  BOOLEAN rr;
    … …  
    985985* a == -1 ?
    986986*/
    987 BOOLEAN nlIsMOne (number a)
     987BOOLEAN nlIsMOne (number a, const coeffs r)
    988988{
    989989#ifdef LDEBUG
    990990  if (a==NULL) return FALSE;
    991   nlTest(a);
     991  nlTest(a, r);
    992992#endif
    993993  //if (SR_HDL(a) & SR_INT) return (a==INT_TO_SR(-1L));
    … …  
    10021002{
    10031003  number result;
    1004   nlTest(a);
    1005   nlTest(b);
     1004  nlTest(a, r);
     1005  nlTest(b, r);
    10061006  //nlNormalize(a);
    10071007  //nlNormalize(b);
    … …  
    10321032    else
    10331033     result=INT_TO_SR(i);
    1034     nlTest(result);
     1034    nlTest(result,r);
    10351035    return result;
    10361036  }
    … …  
    10451045    else
    10461046     result=INT_TO_SR(t);
    1047     nlTest(result);
    10481047  }
    10491048  else
    … …  
    10561055    else
    10571056     result=INT_TO_SR(t);
    1058     nlTest(result);
    10591057  }
    10601058  else
    … …  
    10681066  #endif
    10691067    result=nlShort3(result);
    1070     nlTest(result);
    1071   }
     1068  }
     1069  nlTest(result, r);
    10721070  return result;
    10731071}
    … …  
    11011099  {
    11021100    x=nlShort3_noinline(x);
    1103     nlTest(x);
     1101    nlTest(x,r);
    11041102    return;
    11051103  }
    … …  
    11371135    }
    11381136  }
    1139   nlTest(x);
     1137  nlTest(x, r);
    11401138}
    11411139
    … …  
    11461144{
    11471145  number result;
    1148   nlTest(a);
    1149   nlTest(b);
     1146  nlTest(a, r);
     1147  nlTest(b, r);
    11501148  if ((SR_HDL(b) & SR_INT)
    11511149  || (b->s==3))
    … …  
    11841182  mpz_clear(gcd);
    11851183  result=nlShort3(result);
    1186   nlTest(result);
     1184  nlTest(result, r);
    11871185  return result;
    11881186}
    … …  
    12161214{
    12171215  // Hier brauche ich einfach die GMP Zahl
    1218   nlTest(i);
     1216  nlTest(i, r);
    12191217  nlNormalize(i);
    12201218  if (SR_HDL(i) & SR_INT)
    … …  
    13411339
    13421340// copy not immediate number a
    1343 number _nlCopy_NoImm(number a)
     1341number _nlCopy_NoImm(number a, const coeffs r)
    13441342{
    13451343  assume(!((SR_HDL(a) & SR_INT)||(a==NULL)));
    1346   nlTest(a);
     1344  nlTest(a, r);
    13471345  number b=ALLOC_RNUMBER();
    13481346#if defined(LDEBUG)
    … …  
    13591357  }
    13601358  b->s = a->s;
    1361   nlTest(b);
     1359  nlTest(b, r);
    13621360  return b;
    13631361}
    … …  
    13811379}
    13821380
    1383 number _nlNeg_NoImm(number a)
     1381number _nlNeg_NoImm(number a, const coeffs r)
    13841382{
    13851383  {
    … …  
    13901388    }
    13911389  }
    1392   nlTest(a);
     1390  nlTest(a, r);
    13931391  return a;
    13941392}
    13951393
    1396 number _nlAdd_aNoImm_OR_bNoImm(number a, number b)
     1394number _nlAdd_aNoImm_OR_bNoImm(number a, number b, const coeffs r)
    13971395{
    13981396  number u=ALLOC_RNUMBER();
    … …  
    15571555    }
    15581556  }
    1559   nlTest(u);
     1557  nlTest(u, r);
    15601558  return u;
    15611559}
    15621560
    1563 number _nlSub_aNoImm_OR_bNoImm(number a, number b)
     1561number _nlSub_aNoImm_OR_bNoImm(number a, number b, const coeffs r)
    15641562{
    15651563  number u=ALLOC_RNUMBER();
    … …  
    17811779    }
    17821780  }
    1783   nlTest(u);
     1781  nlTest(u, r);
    17841782  return u;
    17851783}
    17861784
    17871785// a and b are intermediate, but a*b not
    1788 number _nlMult_aImm_bImm_rNoImm(number a, number b)
     1786number _nlMult_aImm_bImm_rNoImm(number a, number b, const coeffs r)
    17891787{
    17901788  number u=ALLOC_RNUMBER();
    … …  
    17951793  mpz_init_set_si(u->z,SR_TO_INT(a));
    17961794  mpz_mul_si(u->z,u->z,SR_TO_INT(b));
    1797   nlTest(u);
     1795  nlTest(u, r);
    17981796  return u;
    17991797}
    18001798
    18011799// a or b are not immediate
    1802 number _nlMult_aNoImm_OR_bNoImm(number a, number b)
     1800number _nlMult_aNoImm_OR_bNoImm(number a, number b, const coeffs r)
    18031801{
    18041802  assume(! (SR_HDL(a) & SR_HDL(b) & SR_INT));
    … …  
    18981896    }
    18991897  }
    1900   nlTest(u);
     1898  nlTest(u, r);
    19011899  return u;
    19021900}
    … …  
    19141912    return a;
    19151913  }
    1916   return _nlCopy_NoImm(a);
    1917 }
     1914  return _nlCopy_NoImm(a, src); // dst?
     1915}
     1916
    19181917nMapFunc nlSetMap(const coeffs src, const coeffs dst)
    19191918{
    19201919  assume( getCoeffType(dst) == ID );
    1921   assume( getCoeffType(src) == ID );
     1920//  assume( getCoeffType(src) == ID );
    19221921 
    19231922  if (nField_is_Q(src))
    … …  
    20182017* a = b ?
    20192018*/
    2020 LINLINE BOOLEAN nlEqual (number a, number b)
    2021 {
    2022   nlTest(a);
    2023   nlTest(b);
     2019LINLINE BOOLEAN nlEqual (number a, number b, const coeffs r)
     2020{
     2021  nlTest(a, r);
     2022  nlTest(b, r);
    20242023// short - short
    20252024  if (SR_HDL(a) & SR_HDL(b) & SR_INT) return a==b;
    … …  
    20342033  if ( ((ii << 3) >> 3) == ii ) n=INT_TO_SR(ii);
    20352034  else                          n=nlRInit(ii);
    2036   nlTest(n);
     2035  nlTest(n, r);
    20372036  return n;
    20382037}
    … …  
    20422041* a == 1 ?
    20432042*/
    2044 LINLINE BOOLEAN nlIsOne (number a)
     2043LINLINE BOOLEAN nlIsOne (number a, const coeffs r)
    20452044{
    20462045#ifdef LDEBUG
    20472046  if (a==NULL) return FALSE;
    2048   nlTest(a);
     2047  nlTest(a, r);
    20492048#endif
    20502049  return (a==INT_TO_SR(1));
    … …  
    20662065    return a;
    20672066  }
    2068   return _nlCopy_NoImm(a);
     2067  return _nlCopy_NoImm(a, r);
    20692068}
    20702069
    … …  
    20772076  if (*a!=NULL)
    20782077  {
    2079     nlTest(*a);
     2078    nlTest(*a, r);
    20802079    if ((SR_HDL(*a) & SR_INT)==0)
    20812080    {
    … …  
    20912090LINLINE number nlNeg (number a, const coeffs r)
    20922091{
    2093   nlTest(a);
     2092  nlTest(a, r);
    20942093  if(SR_HDL(a) &SR_INT)
    20952094  {
    … …  
    20992098    return a;
    21002099  }
    2101   return _nlNeg_NoImm(a);
     2100  return _nlNeg_NoImm(a, r);
    21022101}
    21032102
    … …  
    21162115      return nlRInit(SR_TO_INT(r));
    21172116  }
    2118   return _nlAdd_aNoImm_OR_bNoImm(a, b);
     2117  return _nlAdd_aNoImm_OR_bNoImm(a, b, r);
    21192118}
    21202119
    … …  
    21982197      }
    21992198    }
    2200     nlTest(u);
     2199    nlTest(u, r);
    22012200    return u;
    22022201  }
    … …  
    22682267      }
    22692268    }
    2270     nlTest(a);
     2269    nlTest(a, r);
    22712270    return a;
    22722271  }
    … …  
    22752274LINLINE number nlMult (number a, number b, const coeffs R)
    22762275{
    2277   nlTest(a);
    2278   nlTest(b);
    2279 
     2276  nlTest(a, R);
     2277  nlTest(b, R);
    22802278  if (a==INT_TO_SR(0)) return INT_TO_SR(0);
    22812279  if (b==INT_TO_SR(0)) return INT_TO_SR(0);
    … …  
    22892287      return nlRInit(SR_HDL(u)>>2);
    22902288    }
    2291     return _nlMult_aImm_bImm_rNoImm(a, b);
    2292   }
    2293   return _nlMult_aNoImm_OR_bNoImm(a, b);
     2289    return _nlMult_aImm_bImm_rNoImm(a, b, R);
     2290  }
     2291  return _nlMult_aNoImm_OR_bNoImm(a, b, R);
    22942292}
    22952293
    … …  
    23102308      return nlRInit(SR_TO_INT(r));
    23112309  }
    2312   return _nlSub_aNoImm_OR_bNoImm(a, b);
     2310  return _nlSub_aNoImm_OR_bNoImm(a, b, r);
    23132311}
    23142312
    … …  
    23652363  if ((SR_HDL(b)|SR_HDL(a))&SR_INT)
    23662364  {
    2367     number n=nlIntDiv(a,b);
     2365    number n=nlIntDiv(a,b, r);
    23682366    nlDelete(&a,r);
    23692367    a=n;
    … …  
    24642462}
    24652463
    2466 void nlInitChar(coeffs r, int ch)
    2467 {
     2464void nlInitChar(coeffs r, void* p)
     2465{
     2466  const int ch = (int)(long)(p);
     2467 
    24682468  r->cfKillChar=NULL;
    24692469  r->cfSetChar=NULL;
    … …  
    24912491  r->cfNeg   = nlNeg;
    24922492  r->cfInvers= nlInvers;
    2493   r->cfCopy  = nl_Copy;
    2494   r->cfRePart = nl_Copy;
     2493  r->cfCopy  = nlCopy;
     2494  r->cfRePart = nlCopy;
    24952495  //r->cfImPart = ndReturn0;
    24962496  r->cfWrite = nlWrite;

  • coeffs/longrat.h

    rc3d175 r2b957a  
    5858LINLINE number   nlMult(number a, number b, const coeffs r);
    5959
    60 void     nlInitChar(coeffs r, int ch);
     60void     nlInitChar(coeffs r, void*);
     61static BOOLEAN nlCoeffsEqual(const coeffs r, n_coeffType n, void * parameter);
    6162
    6263number   nlInit2 (int i, int j, const coeffs r);
    … …  
    115116
    116117#ifdef LDEBUG
    117 #define nlTest(a) nlDBTest(a,__FILE__,__LINE__)
    118 BOOLEAN nlDBTest(number a, char *f,int l);
     118#define nlTest(a, r) nlDBTest(a,__FILE__,__LINE__, r)
     119BOOLEAN nlDBTest(number a, char *f,int l, const coeffs r);
    119120#else
    120 #define nlTest(a) ((void)0)
     121#define nlTest(a, r) ((void)0)
    121122#endif
    122123

  • coeffs/modulop.cc

    rc3d175 r2b957a  
    439439
    440440#ifdef LDEBUG
    441 BOOLEAN npDBTest (number a, const coeffs r, const char *f, const int l)
     441BOOLEAN npDBTest (number a, const char *f, const int l, const coeffs r)
    442442{
    443443  if (((long)a<0) || ((long)a>r->npPrimeM))
    … …  
    452452number npMap0(number from, const coeffs src, const coeffs dst_r)
    453453{
    454   return npInit(nlModP(from,dst_r->npPrimeM),dst_r);
     454  int nlModP(number n, int p, const coeffs r);
     455
     456  return npInit(nlModP(from, dst_r->npPrimeM, src),dst_r);
    455457}
    456458

  • coeffs/modulop.h

    rc3d175 r2b957a  
    4444const char *  npRead  (const char *s, number *a,const coeffs r);
    4545#ifdef LDEBUG
    46 BOOLEAN npDBTest      (number a,const coeffs r, const char *f, const int l);
    47 #define npTest(A,r)     npDBTest(A,r,__FILE__,__LINE__)
     46BOOLEAN npDBTest      (number a, const char *f, const int l, const coeffs r);
     47#define npTest(A,r)     npDBTest(A,__FILE__,__LINE__, r)
    4848#else
    4949#define npTest(A,r)     (0)

  • coeffs/mpr_complex.cc

    rc3d175 r2b957a  
    3838size_t gmp_output_digits= DEFPREC;
    3939
    40 extern int mmInit(void);
    41 int dummy=mmInit();
     40// extern int mmInit(void); // TODO: From Factory???
     41//{ return 0; }; //
     42// int dummy=mmInit();
     43
     44
    4245static gmp_float *gmpRel=NULL;
    4346static gmp_float *diff=NULL;

  • coeffs/numbers.cc

    rc3d175 r2b957a  
    6060#ifdef LDEBUG
    6161void   nDBDummy1(number* d,char *f, int l) { *d=NULL; }
    62 BOOLEAN ndDBTest(number a, const char *f, const int l)
     62BOOLEAN ndDBTest(number a, const char *f, const int l, const coeffs r)
    6363{
    6464  return TRUE;

  • coeffs/numbers.h

    rc3d175 r2b957a  
    3232#ifdef LDEBUG
    3333void nDBDummy1(number* d,char *f, int l);
     34BOOLEAN ndDBTest(number a, const char *f, const int l, const coeffs r);
    3435#endif
    3536

  • coeffs/shortfl.cc

    rc3d175 r2b957a  
    353353* test valid numbers: not implemented yet
    354354*/
    355 BOOLEAN  nrDBTest(number a, const char *f, const int l, const coeffs r);
     355BOOLEAN  nrDBTest(number a, const char *f, const int l, const coeffs r)
    356356{
    357357  assume( getCoeffType(r) == ID );
    … …  
    538538
    539539/// test, whether r is an instance of nInitCoeffs(n, parameter) */
    540 static BOOLEAN nrCoeffsEqual(const coeffs r, n_coeffType n, int parameter)
     540static BOOLEAN nrCoeffsEqual(const coeffs r, n_coeffType n, void* parameter)
    541541{
    542542  assume( getCoeffType(r) == ID );
    … …  
    547547
    548548
    549 void nrInitChar(coeffs n, int)
     549void nrInitChar(coeffs n, void*)
    550550{
    551551  assume( getCoeffType(n) == ID );

  • coeffs/shortfl.h

    rc3d175 r2b957a  
    1515
    1616/// Initialize r
    17 void nrInitChar(coeffs r, int);
     17void nrInitChar(coeffs r, void*);
    1818
    1919/// test, whether r is an instance of nInitCoeffs(n, parameter) */
    20 static BOOLEAN nrCoeffsEqual(const coeffs r, n_coeffType n, int parameter);
     20static BOOLEAN nrCoeffsEqual(const coeffs r, n_coeffType n, void* parameter);
    2121
    2222
    23 /* // Private interface should be hidden!!!
     23// Private interface should be hidden!!!
    2424
    2525BOOLEAN nrGreaterZero (number k, const coeffs r);
    … …  
    4343BOOLEAN nrDBTest(number a, const coeffs r, const char *f, const int l);
    4444#endif
    45 */
    4645
    4746

  • coeffs/test.cc

    rc3d175 r2b957a  
    88
    99
    10 //#include <longrat.h>
     10#include <longrat.h>
    1111#include <gnumpc.h>
     12#include <shortfl.h>
    1213
    1314
    … …  
    1819int main()
    1920{
    20   const n_coeffType type = n_long_C; // n_Q;
     21  SPrintStart();
     22 
     23  const n_coeffType type = nRegister( n_Q, nlInitChar); assume( type == n_Q );
     24//  const n_coeffType type = nRegister( n_long_C, ngcInitChar); assume( type == n_long_C );
     25//  const n_coeffType type = nRegister( n_R, nrInitChar); assume( type == n_R );
     26 
    2127
    2228  const coeffs r = nInitChar( type, NULL );
    2329
    2430  assume( r != NULL );
     31 
     32  nSetChar( r );
     33
     34  assume( getCoeffType(r) == type );
    2535
    2636  assume( r->cfInit != NULL );
    … …  
    2838  assume( r->cfAdd != NULL );
    2939  assume( r->cfDelete != NULL );
    30 
    31   assume( getCoeffType(r) == type );
     40 
    3241
    3342  if( type == n_Q )
    3443  {
    35    
    36 /*
    3744    assume( r->cfInit == nlInit );
    3845    assume( r->cfWrite == nlWrite );
    3946    assume( r->cfAdd == nlAdd );
    4047    assume( r->cfDelete == nlDelete );   
    41 */
    42     }
     48  }
    4349  else if( type == n_long_C )
    4450  {
    … …  
    4854    assume( r->cfDelete == ngcDelete );   
    4955  }
     56  else if( type == n_R )
     57  {
     58    assume( r->cfInit == nrInit );
     59    assume( r->cfWrite == nrWrite );
     60    assume( r->cfAdd == nrAdd );
     61//    assume( r->cfDelete == nrDelete ); // No?
     62  } else
     63  {
     64    // ...
     65  }
    5066
    5167
    5268 
    5369  number a = r->cfInit(666, r);
     70  number b = r->cfAdd( a, a, r);
     71
    5472  r->cfWrite( a, r );
    55   number b = r->cfAdd( a, a, r);
    5673  r->cfWrite( b, r );
     74 
    5775  r->cfDelete( &a, r);
    5876  r->cfDelete( &b, r);
    5977
    60  
     78  nKillChar( r );
     79
     80  cout << "OUTPUT BUFFER: " << SPrintEnd();
    6181 
    6282  return 0;
Note: See TracChangeset for help on using the changeset viewer.