Changeset 30d574 in git for Singular/interpolation.cc


Ignore:
Timestamp:
Nov 11, 2010, 10:23:22 AM (13 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'spielwiese', '17f1d200f27c5bd38f5dfc6e8a0879242279d1d8')
Children:
a80025e8d85c97a2cc2a6b86ef219a392df4f2b5
Parents:
d882518b93f286d7db8ab355fea6f1781b41f6d1
Message:
unused debugging routines removed

git-svn-id: file:///usr/local/Singular/svn/trunk@13631 2c84dea3-7e68-4137-9b89-c4e89433aadc
File:
1 edited

Legend:

Unmodified
Added
Removed

  • Singular/interpolation.cc

    rd88251 r30d574  
    1515#include <kernel/ring.h>
    1616#ifdef HAVE_FACTORY
     17#define SI_DONT_HAVE_GLOBAL_VARS
    1718#  include <factory/factory.h>
    1819#endif /* HAVE_FACTORY */
    1920
    20 //memory management
    21 #define mdmALLOC(x) omAlloc0(x)
    22 #define mdmFREE(x) omFree(x)
    23 
    2421// parameters to debug
    25 //#define debb
    2622//#define shmat
    2723//#define checksize
    … …  
    144140#endif
    145141
     142#if 0  /* only for debuggig*/
    146143void WriteMono (mono_type m) // Writes a monomial on the screen - only for debug
    147144{
    … …  
    151148}
    152149
    153 #ifdef debb
    154150void WriteMonoList (mon_list_entry *list)
    155151{
    … …  
    228224   u1=1; u2=0;
    229225   u = a; v = p;
    230    while (v != 0) {
     226   while (v != 0)
     227   {
    231228      q = u / v;
    232229      r = u % v;
    … …  
    310307           if (Greater ((*curptr).mon,mon)) break;
    311308           prevptr=curptr;
    312            curptr=curptr->next;}
    313      temp=(mon_list_entry*)mdmALLOC(sizeof(mon_list_entry));
     309           curptr=curptr->next;
     310     }
     311     temp=(mon_list_entry*)omAlloc0(sizeof(mon_list_entry));
    314312     (*temp).next=curptr;
    315      (*temp).mon=(exponent*)mdmALLOC(sizeof(exponent)*variables);
     313     (*temp).mon=(exponent*)omAlloc0(sizeof(exponent)*variables);
    316314     memcpy(temp->mon,mon,sizeof(exponent)*variables);
    317      if (prevptr==NULL) return temp; else {
     315     if (prevptr==NULL) return temp;
     316     else
     317     {
    318318          prevptr->next=temp;
    319           return list;}
     319          return list;
     320     }
    320321}
    321322
    … …  
    331332{
    332333     mono_type m;
    333      m=(exponent*)mdmALLOC(sizeof(exponent)*variables);
     334     m=(exponent*)omAlloc0(sizeof(exponent)*variables);
    334335     int i;
    335336     for (i=0;i<variables;i++) m[i]=0;
    … …  
    340341{
    341342     int i,j,k;
    342      points=(coordinates*)mdmALLOC(sizeof(coordinates)*n_points);
     343     points=(coordinates*)omAlloc0(sizeof(coordinates)*n_points);
    343344     for (i=0;i<n_points;i++)
    344345     {
    345          points[i]=(coordinate_products*)mdmALLOC(sizeof(coordinate_products)*variables);
    346          for (j=0;j<variables;j++) points[i][j]=(modp_number*)mdmALLOC(sizeof(modp_number)*(max_coord));
    347      }
    348      condition_list=(condition_type*)mdmALLOC(sizeof(condition_type)*final_base_dim);
    349      for (i=0;i<final_base_dim;i++) condition_list[i].mon=(exponent*)mdmALLOC(sizeof(exponent)*variables);
    350      modp_points=(modp_coordinates*)mdmALLOC(sizeof(modp_coordinates)*n_points);
    351      for (i=0;i<n_points;i++) modp_points[i]=(modp_number*)mdmALLOC(sizeof(modp_number)*variables);
     346         points[i]=(coordinate_products*)omAlloc0(sizeof(coordinate_products)*variables);
     347         for (j=0;j<variables;j++) points[i][j]=(modp_number*)omAlloc0(sizeof(modp_number)*(max_coord));
     348     }
     349     condition_list=(condition_type*)omAlloc0(sizeof(condition_type)*final_base_dim);
     350     for (i=0;i<final_base_dim;i++) condition_list[i].mon=(exponent*)omAlloc0(sizeof(exponent)*variables);
     351     modp_points=(modp_coordinates*)omAlloc0(sizeof(modp_coordinates)*n_points);
     352     for (i=0;i<n_points;i++) modp_points[i]=(modp_number*)omAlloc0(sizeof(modp_number)*variables);
    352353     if (!only_modp)
    353354     {
    354         q_points=(q_coordinates*)mdmALLOC(sizeof(q_coordinates)*n_points);
     355        q_points=(q_coordinates*)omAlloc0(sizeof(q_coordinates)*n_points);
    355356        for (i=0;i<n_points;i++)
    356357        {
    357             q_points[i]=(mpq_t*)mdmALLOC(sizeof(mpq_t)*variables);
     358            q_points[i]=(mpq_t*)omAlloc0(sizeof(mpq_t)*variables);
    358359            for (j=0;j<variables;j++) mpq_init(q_points[i][j]);
    359360        }
    360         int_points=(int_coordinates*)mdmALLOC(sizeof(int_coordinates)*n_points);
     361        int_points=(int_coordinates*)omAlloc0(sizeof(int_coordinates)*n_points);
    361362        for (i=0;i<n_points;i++)
    362363        {
    363             int_points[i]=(mpz_t*)mdmALLOC(sizeof(mpz_t)*variables);
     364            int_points[i]=(mpz_t*)omAlloc0(sizeof(mpz_t)*variables);
    364365            for (j=0;j<variables;j++) mpz_init(int_points[i][j]);
    365366        }
    366367     }
    367      coord_exist=(coord_exist_table*)mdmALLOC(sizeof(coord_exist_table)*n_points);
     368     coord_exist=(coord_exist_table*)omAlloc0(sizeof(coord_exist_table)*n_points);
    368369     for (i=0;i<n_points;i++)
    369370     {
    370          coord_exist[i]=(bool*)mdmALLOC(sizeof(bool)*variables);
     371         coord_exist[i]=(bool*)omAlloc0(sizeof(bool)*variables);
    371372         for (j=0;j<variables;j++) coord_exist[i][j]=false;
    372373     }
    373      generic_column_name=(mono_type*)mdmALLOC(sizeof(mono_type)*final_base_dim);
     374     generic_column_name=(mono_type*)omAlloc0(sizeof(mono_type)*final_base_dim);
    374375     for (i=0;i<final_base_dim;i++) generic_column_name[i]=ZeroMonomial ();
    375376     good_primes=0;
    … …  
    378379     if (!only_modp)
    379380     {
    380         polycoef=(mpz_t*)mdmALLOC(sizeof(mpz_t)*(final_base_dim+1));
    381         polyexp=(mono_type*)mdmALLOC(sizeof(mono_type)*(final_base_dim+1));
     381        polycoef=(mpz_t*)omAlloc0(sizeof(mpz_t)*(final_base_dim+1));
     382        polyexp=(mono_type*)omAlloc0(sizeof(mono_type)*(final_base_dim+1));
    382383        for (i=0;i<=final_base_dim;i++)
    383384        {
    … …  
    403404     int i,j;
    404405     check_list=MonListAdd (check_list,ZeroMonomial ());
    405      my_row=(modp_number*)mdmALLOC(sizeof(modp_number)*final_base_dim);
    406      my_solve_row=(modp_number*)mdmALLOC(sizeof(modp_number)*final_base_dim);
    407      column_name=(mono_type*)mdmALLOC(sizeof(mono_type)*final_base_dim);
     406     my_row=(modp_number*)omAlloc0(sizeof(modp_number)*final_base_dim);
     407     my_solve_row=(modp_number*)omAlloc0(sizeof(modp_number)*final_base_dim);
     408     column_name=(mono_type*)omAlloc0(sizeof(mono_type)*final_base_dim);
    408409     for (i=0;i<final_base_dim;i++) column_name[i]=ZeroMonomial ();
    409410     last_solve_column=0;
    … …  
    411412     modp_number pos_gen;
    412413     bool gen_ok;
    413      modp_Reverse=(modp_number*)mdmALLOC(sizeof(modp_number)*myp);
     414     modp_Reverse=(modp_number*)omAlloc0(sizeof(modp_number)*myp);
    414415
    415416// produces table of modp inverts by finding a generator of (Z_myp*,*)
    416      gen_table=(modp_number*)mdmALLOC(sizeof(modp_number)*myp);
     417     gen_table=(modp_number*)omAlloc0(sizeof(modp_number)*myp);
    417418     gen_table[1]=1;
    418419     for (pos_gen=2;pos_gen<myp;pos_gen++)
    … …  
    432433     for (i=2;i<myp;i++) modp_Reverse[gen_table[i]]=gen_table[myp-i+1];
    433434     modp_Reverse[1]=1;
    434      mdmFREE(gen_table);
     435     omFree(gen_table);
    435436}
    436437
    … …  
    443444     {
    444445           pptr=ptr->next;
    445            mdmFREE(ptr->mon);
    446            mdmFREE(ptr);
     446           omFree(ptr->mon);
     447           omFree(ptr);
    447448           ptr=pptr;}
    448449     return NULL;
    … …  
    456457         for (j=0;j<variables;j++)
    457458         {
    458              mdmFREE(points[i][j]);
     459             omFree(points[i][j]);
    459460         }
    460          mdmFREE(points[i]);
    461      }
    462      mdmFREE(points);
    463      for (i=0;i<final_base_dim;i++) mdmFREE(condition_list[i].mon);
    464      mdmFREE(condition_list);
    465      for (i=0;i<n_points;i++) mdmFREE(modp_points[i]);
    466      mdmFREE(modp_points);
     461         omFree(points[i]);
     462     }
     463     omFree(points);
     464     for (i=0;i<final_base_dim;i++) omFree(condition_list[i].mon);
     465     omFree(condition_list);
     466     for (i=0;i<n_points;i++) omFree(modp_points[i]);
     467     omFree(modp_points);
    467468     if (!only_modp)
    468469     {
    … …  
    470471        {
    471472            for (j=0;j<variables;j++) mpq_clear(q_points[i][j]);
    472             mdmFREE(q_points[i]);
    473         }
    474         mdmFREE(q_points);
     473            omFree(q_points[i]);
     474        }
     475        omFree(q_points);
    475476        for (i=0;i<n_points;i++)
    476477        {
    477478            for (j=0;j<variables;j++) mpz_clear(int_points[i][j]);
    478             mdmFREE(int_points[i]);
    479         }
    480         mdmFREE(int_points);
     479            omFree(int_points[i]);
     480        }
     481        omFree(int_points);
    481482        generic_lt=FreeMonList (generic_lt);
    482483        for (i=0;i<=final_base_dim;i++)
    483484        {
    484485            mpz_clear(polycoef[i]);
    485             mdmFREE(polyexp[i]);
    486         }
    487         mdmFREE(polycoef);
    488         mdmFREE(polyexp);
     486            omFree(polyexp[i]);
     487        }
     488        omFree(polycoef);
     489        omFree(polyexp);
    489490        if (!only_modp) mpz_clear(common_denom);
    490491     }
    491492     for (i=0;i<final_base_dim;i++)
    492493     {
    493          mdmFREE(generic_column_name[i]);
    494      }
    495      mdmFREE(generic_column_name);
    496      for (i=0;i<n_points;i++) mdmFREE(coord_exist[i]);
    497      mdmFREE(coord_exist);
     494         omFree(generic_column_name[i]);
     495     }
     496     omFree(generic_column_name);
     497     for (i=0;i<n_points;i++) omFree(coord_exist[i]);
     498     omFree(coord_exist);
    498499     pDelete(&comparizon_p1);
    499500     pDelete(&comparizon_p2);
    … …  
    508509     lt_list=FreeMonList (lt_list);
    509510     base_list=FreeMonList (base_list);
    510      mdmFREE(my_row);
     511     omFree(my_row);
    511512     my_row=NULL;
    512      mdmFREE(my_solve_row);
     513     omFree(my_solve_row);
    513514     my_solve_row=NULL;
    514515     ptr=row_list;
    … …  
    516517     {
    517518           pptr=ptr->next;
    518            mdmFREE(ptr->row_matrix);
    519            mdmFREE(ptr->row_solve);
    520            mdmFREE(ptr);
     519           omFree(ptr->row_matrix);
     520           omFree(ptr->row_solve);
     521           omFree(ptr);
    521522           ptr=pptr;
    522523     }
    523524     row_list=NULL;
    524      for (i=0;i<final_base_dim;i++) mdmFREE(column_name[i]);
    525      mdmFREE(column_name);
    526      mdmFREE(modp_Reverse);
     525     for (i=0;i<final_base_dim;i++) omFree(column_name[i]);
     526     omFree(column_name);
     527     omFree(modp_Reverse);
    527528}
    528529
    … …  
    536537    int j,k;
    537538    mono_type mn;
    538     mn=(exponent*)mdmALLOC(sizeof(exponent)*variables);
     539    mn=(exponent*)omAlloc0(sizeof(exponent)*variables);
    539540    memcpy(mn,mon,sizeof(exponent)*variables);
    540541    for (k=0;k<variables;k++)
    … …  
    547548        *ev=modp_mul(*ev,points[con.point_ref][k][mn[k]]);
    548549    }
    549     mdmFREE(mn);
     550    omFree(mn);
    550551}
    551552
    … …  
    561562    int j,k;
    562563    mono_type mn;
    563     mn=(exponent*)mdmALLOC(sizeof(exponent)*variables);
     564    mn=(exponent*)omAlloc0(sizeof(exponent)*variables);
    564565    memcpy(mn,mon,sizeof(exponent)*variables);
    565566    for (k=0;k<variables;k++)
    … …  
    573574        for (j=1;j<=mn[k];j++) mpz_mul(ev,ev,int_points[con.point_ref][k]);  // this loop computes the product of coordinate
    574575    }
    575     mdmFREE(mn);
     576    omFree(mn);
    576577    mpz_clear(mon_conv);
    577578}
    … …  
    693694         }
    694695     }
    695      mdmFREE(mon);
     696     omFree(mon);
    696697}
    697698
    … …  
    765766           }
    766767           row_ptr=row_ptr->next;
    767 #ifdef debb
     768#if 0 /* only debugging */
    768769           PrintS("reduction by row ");
    769770           Info ();
    … …  
    805806          if (DivisibleMon (m,c_ptr->mon))
    806807          {
    807              if (p_ptr==NULL) 
     808             if (p_ptr==NULL)
    808809                check_list=c_ptr->next;
    809810             else
    810811                p_ptr->next=c_ptr->next;
    811812             n_ptr=c_ptr->next;
    812              mdmFREE(c_ptr->mon);
    813              mdmFREE(c_ptr);
     813             omFree(c_ptr->mon);
     814             omFree(c_ptr);
    814815             c_ptr=n_ptr;
    815816          }
    … …  
    829830        memcpy(mon,check_list->mon,sizeof(exponent)*variables);
    830831        n_check_list=check_list->next;
    831         mdmFREE(check_list->mon);
    832         mdmFREE(check_list);
     832        omFree(check_list->mon);
     833        omFree(check_list);
    833834        check_list=n_check_list;
    834835     }
    … …  
    872873         ptr=ptr->next;
    873874     }
    874      temp=(row_list_entry*)mdmALLOC(sizeof(row_list_entry));
    875      (*temp).row_matrix=(modp_number*)mdmALLOC(sizeof(modp_number)*final_base_dim);
     875     temp=(row_list_entry*)omAlloc0(sizeof(row_list_entry));
     876     (*temp).row_matrix=(modp_number*)omAlloc0(sizeof(modp_number)*final_base_dim);
    876877     memcpy((*temp).row_matrix,my_row,sizeof(modp_number)*(final_base_dim));
    877      (*temp).row_solve=(modp_number*)mdmALLOC(sizeof(modp_number)*final_base_dim);
     878     (*temp).row_solve=(modp_number*)omAlloc0(sizeof(modp_number)*final_base_dim);
    878879     memcpy((*temp).row_solve,my_solve_row,sizeof(modp_number)*(final_base_dim));
    879880     (*temp).first_col=first_col;
    … …  
    941942    modp_result_entry *temp;
    942943    int i;
    943     temp=(modp_result_entry*)mdmALLOC(sizeof(modp_result_entry));
     944    temp=(modp_result_entry*)omAlloc0(sizeof(modp_result_entry));
    944945    if (cur_result==NULL)
    945946    {
    … …  
    968969     {
    969970         next_gen=cur_gen->next;
    970          mdmFREE(cur_gen->coef);
    971          mdmFREE(cur_gen->lt);
    972          mdmFREE(cur_gen);
     971         omFree(cur_gen->coef);
     972         omFree(cur_gen->lt);
     973         omFree(cur_gen);
    973974         cur_gen=next_gen;
    974975     }
    975      mdmFREE(e);
     976     omFree(e);
    976977}
    977978
    … …  
    990991         cur_ptr=cur_ptr->next;
    991992     }
    992      temp=(generator_entry*)mdmALLOC(sizeof(generator_entry));
     993     temp=(generator_entry*)omAlloc0(sizeof(generator_entry));
    993994     if (prev_ptr==NULL) cur_result->generator=temp; else prev_ptr->next=temp;
    994995     temp->next=NULL;
    995      temp->coef=(modp_number*)mdmALLOC(sizeof(modp_number)*final_base_dim);
     996     temp->coef=(modp_number*)omAlloc0(sizeof(modp_number)*final_base_dim);
    996997     memcpy(temp->coef,my_solve_row,sizeof(modp_number)*final_base_dim);
    997998     temp->lt=ZeroMonomial ();
    … …  
    10091010     while (cur_ptr!=NULL)
    10101011     {
    1011          for (i=0;i<final_base_dim;i++) 
     1012         for (i=0;i<final_base_dim;i++)
    10121013             cur_ptr->coef[i]=modp_mul(cur_ptr->coef[i],modp_denom);
    10131014         cur_ptr->ltcoef=modp_denom;
    … …  
    10161017#endif
    10171018}
    1018 
     1019#if 0 /* only debbuging */
    10191020void PresentGenerator (int i)  // only for debuging, writes a generator in its form in program
    10201021{
    … …  
    10371038     }
    10381039}
     1040#endif
    10391041
    10401042modp_number TakePrime (modp_number p)  // takes "previous" (smaller) prime
    … …  
    10551057     modp_number *congr_ptr;
    10561058     modp_number prod;
    1057      in_gamma=(modp_number*)mdmALLOC(sizeof(modp_number)*n);
    1058      congr=(modp_number*)mdmALLOC(sizeof(modp_number)*n);
     1059     in_gamma=(modp_number*)omAlloc0(sizeof(modp_number)*n);
     1060     congr=(modp_number*)omAlloc0(sizeof(modp_number)*n);
    10591061     congr_ptr=congr;
    10601062     while (cur_ptr!=NULL)
    … …  
    10771079void CloseChinese (int n) // after CRA
    10781080{
    1079      mdmFREE(in_gamma);
    1080      mdmFREE(congr);
     1081     omFree(in_gamma);
     1082     omFree(congr);
    10811083     mpz_clear(bigcongr);
    10821084}
    … …  
    11111113     int coef;
    11121114     char *str=NULL;
    1113      str=(char*)mdmALLOC(sizeof(char)*1000);
     1115     str=(char*)omAlloc0(sizeof(char)*1000);
    11141116     modp_result_entry *cur_ptr;
    11151117     generator_entry *cur_gen;
    … …  
    11211123     mpz_init(sol);
    11221124     mpz_init(nsol);
    1123      u=(modp_number*)mdmALLOC(sizeof(modp_number)*n);
    1124      v=(modp_number*)mdmALLOC(sizeof(modp_number)*n);
     1125     u=(modp_number*)omAlloc0(sizeof(modp_number)*n);
     1126     v=(modp_number*)omAlloc0(sizeof(modp_number)*n);
    11251127     for (coef=0;coef<=final_base_dim;coef++)
    11261128     {
    … …  
    11631165#endif
    11641166     }
    1165      mdmFREE(u);
    1166      mdmFREE(v);
    1167      mdmFREE(str);
     1167     omFree(u);
     1168     omFree(v);
     1169     omFree(str);
    11681170     ClearGCD ();
    11691171     mpz_clear(sol);
    … …  
    12841286     good_primes++;
    12851287}
    1286 
     1288#if 0 /* only debuggig */
    12871289void WriteGenerator () // writes generator (only for debugging)
    12881290{
    12891291     char *str;
    1290      str=(char*)mdmALLOC(sizeof(char)*1000);
     1292     str=(char*)omAlloc0(sizeof(char)*1000);
    12911293     int i;
    12921294     for (i=0;i<=final_base_dim;i++)
    … …  
    12981300         PrintS(" ");
    12991301     }
    1300      mdmFREE(str);
     1302     omFree(str);
    13011303     PrintLn();
    13021304}
     1305#endif
    13031306
    13041307bool CheckGenerator () // evaluates generator to check whether it is good
    … …  
    13391342         {
    13401343             mpz_clear(gen_list->polycoef[i]);
    1341              mdmFREE(gen_list->polyexp[i]);
     1344             omFree(gen_list->polyexp[i]);
    13421345         }
    1343          mdmFREE(gen_list->polycoef);
    1344          mdmFREE(gen_list->polyexp);
    1345          mdmFREE(gen_list);
     1346         omFree(gen_list->polycoef);
     1347         omFree(gen_list->polyexp);
     1348         omFree(gen_list);
    13461349         gen_list=temp;
    13471350      }
    … …  
    13691372         temp=temp->next;
    13701373     }
    1371      temp=(gen_list_entry*)mdmALLOC(sizeof(gen_list_entry));
     1374     temp=(gen_list_entry*)omAlloc0(sizeof(gen_list_entry));
    13721375     if (prev==NULL) gen_list=temp; else prev->next=temp;
    13731376     temp->next=NULL;
    1374      temp->polycoef=(mpz_t*)mdmALLOC(sizeof(mpz_t)*(final_base_dim+1));
    1375      temp->polyexp=(mono_type*)mdmALLOC(sizeof(mono_type)*(final_base_dim+1));
     1377     temp->polycoef=(mpz_t*)omAlloc0(sizeof(mpz_t)*(final_base_dim+1));
     1378     temp->polyexp=(mono_type*)omAlloc0(sizeof(mono_type)*(final_base_dim+1));
    13761379     for (i=0;i<=final_base_dim;i++)
    13771380     {
    … …  
    13831386}
    13841387
     1388#if 0 /* only debugging */
    13851389void ShowGenList ()
    13861390{
    … …  
    13881392     int i;
    13891393     char *str;
    1390      str=(char*)mdmALLOC(sizeof(char)*1000);
     1394     str=(char*)omAlloc0(sizeof(char)*1000);
    13911395     temp=gen_list;
    13921396     while (temp!=NULL)
    … …  
    14031407         temp=temp->next;
    14041408     }
    1405      mdmFREE(str);
    1406 }
     1409     omFree(str);
     1410}
     1411#endif
    14071412
    14081413
    … …  
    14141419     bool row_is_zero;
    14151420
    1416 #ifdef debb
     1421#if 0 /* only debugging */
    14171422     Info ();
    14181423#endif
    … …  
    14221427           TakeNextMonomial (cur_mon);
    14231428           ProduceRow (cur_mon);
    1424 #ifdef debb
     1429#if 0 /* only debugging */
    14251430           cout << "row produced for monomial ";
    14261431           WriteMono (cur_mon);
    … …  
    14351440              ReduceCheckListByMon (cur_mon);
    14361441              NewGenerator (cur_mon);
    1437 #ifdef debb
     1442#if 0 /* only debugging */
    14381443              cout << "row is zero - linear dependence found (should be seen in my_solve_row)" << endl;
    14391444              cout << "monomial added to leading terms list" << endl;
    … …  
    14471452              UpdateCheckList (cur_mon);
    14481453              ReduceCheckListByLTs ();
    1449 #ifdef debb
     1454#if 0 /* only debugging */
    14501455              cout << "row is non-zero" << endl;
    14511456              cout << "monomial added to quotient basis list" << endl;
    … …  
    14551460#endif
    14561461              PrepareRow (cur_mon);
    1457 #ifdef debb
     1462#if 0 /* only debugging */
    14581463              cout << "row prepared and put into matrix" << endl;
    14591464              Info ();
    … …  
    14611466           }
    14621467        }
    1463         mdmFREE(cur_mon);
     1468        omFree(cur_mon);
    14641469}
    14651470
Note: See TracChangeset for help on using the changeset viewer.