Changeset 11d9bec in tol


Ignore:
Timestamp:
Nov 21, 2011, 11:53:04 AM (15 years ago)
Author:
Víctor de Buen <vdebuen@…>
Branches:
1941-docker-image-to-test, devel, master
Children:
523e2d1
Parents:
9f6ab11
Message:

Fixes #1339

git-svn-id: ​https://www.tol-project.org/svn/tolp/trunk@3861 be4846ae-f051-483a-831f-b64e7d08527f

File:
1 edited

Legend:

Unmodified
Added
Removed

  • tol/btol/serie_type/tsrgrav.cpp

    r9f6ab11 r11d9bec  
    8585//--------------------------------------------------------------------
    8686{
    87     if(!Dating()) { return(BDat::Unknown()); }
     87  BDat dat;
     88  BUserTimeSet* dating = Dating();
     89  if(dating && (dating->Inf()<=dte) && (dating->Sup()>=dte))
     90  {
    8891    BUniformDist var(Real(Arg(1)),Real(Arg(2)));
    89     return(var.Random());
     92    dat = var.Random();
     93  }
     94  return(dat);
    9095}
    9196
    … …  
    125130BDat BTsrGaussian::GetDat(const BDate& dte)
    126131{
    127     BDat newValue;
     132  BDat dat;
     133  BUserTimeSet* dating = Dating();
     134  if(dating && (dating->Inf()<=dte) && (dating->Sup()>=dte))
     135  {
    128136    std::map<double, BDat>::const_iterator keyIterator;
    129 
    130     if(!Dating()) newValue = BDat::Unknown();
    131     else {
    132   keyIterator = valuesMap_.find(dte.Hash());
    133   if(keyIterator == valuesMap_.end()) {
    134       newValue = dist_.Random();
    135       valuesMap_.insert(std::pair<double, BDat>(dte.Hash(), newValue));
    136   } else newValue = keyIterator->second;
    137     }
    138 
    139     return(newValue);
     137    keyIterator = valuesMap_.find(dte.Hash());
     138    if(keyIterator == valuesMap_.end())
     139    {
     140      dat = dist_.Random();
     141      valuesMap_.insert(std::pair<double, BDat>(dte.Hash(), dat));
     142    }
     143    else
     144    {
     145      dat = keyIterator->second;
     146    }
     147  }
     148  return(dat);
    140149}
    141150
    … …  
    179188//--------------------------------------------------------------------
    180189{
    181   if(!Dating()) { return(BDat::Unknown()); }
    182   if(dte == Center()) { return(BDat(1.0)); }
    183   else          { return(BDat(0.0)); }
    184 }
    185 
     190  BDat dat;
     191  BUserTimeSet* dating = Dating();
     192  if(dating && (dating->Inf()<=dte) && (dating->Sup()>=dte))
     193  {
     194    if(!Dating()) { return(BDat::Unknown()); }
     195    if(dte == Center()) { return(BDat(1.0)); }
     196    else          { return(BDat(0.0)); }
     197  }
     198  return(dat);
     199}
    186200
    187201//--------------------------------------------------------------------
    … …  
    199213//--------------------------------------------------------------------
    200214{
    201   if(!Dating()) { return(BDat::Unknown()); }
    202        if(dte == Center())     { return(BDat( 1.0)); }
    203   else if(dte == PostCenter()) { return(BDat(-1.0)); }
    204   else             { return(BDat( 0.0)); }
     215  BDat dat;
     216  BUserTimeSet* dating = Dating();
     217  if(dating && (dating->Inf()<=dte) && (dating->Sup()>=dte))
     218  {
     219         if(dte == Center())     { return(BDat( 1.0)); }
     220    else if(dte == PostCenter()) { return(BDat(-1.0)); }
     221    else             { return(BDat( 0.0)); }
     222  }
     223  return(dat);
    205224}
    206225
    … …  
    220239//--------------------------------------------------------------------
    221240{
    222   if(!Dating()) { return(BDat::Unknown()); }
    223   if(dte >= Center()) { return(BDat(1.0)); }
    224   else          { return(BDat(0.0)); }
     241  BDat dat;
     242  BUserTimeSet* dating = Dating();
     243  if(dating && (dating->Inf()<=dte) && (dating->Sup()>=dte))
     244  {
     245    if(dte >= Center()) { return(BDat(1.0)); }
     246    else          { return(BDat(0.0)); }
     247  }
     248  return(dat);
     249
    225250}
    226251
    … …  
    242267//--------------------------------------------------------------------
    243268{
    244   BDate d;
    245   if(!Dating()) { return(BDat::Unknown()); }
    246   if(dte<Center()) { return(BDat(0.0)); }
    247   else {
    248    d = Dating()->FirstNoLess (Center());
    249    return(Dating()->Difference(d, dte)+1);
    250  }
     269  BDat dat;
     270  BUserTimeSet* dating = Dating();
     271  if(dating && (dating->Inf()<=dte) && (dating->Sup()>=dte))
     272  {
     273    BDate d;
     274    if(dte<Center()) { return(BDat(0.0)); }
     275    else
     276    {
     277      d = dating->FirstNoLess (Center());
     278      return(dating->Difference(d, dte)+1);
     279    }
     280  }
     281  return(dat);
    251282}
    252283
    … …  
    278309//--------------------------------------------------------------------
    279310{
    280   if(!Dating()) { return(BDat::Unknown()); }
    281   BDat dat;
    282   if(d0!=d1)
    283   {
    284     if(y1!=y0)
    285     {
    286       BReal pendient = (y1-y0)/Dating()->Difference(d0, d1);
    287       dat = y0 + pendient*Dating()->Difference(d0, dte);
    288     }
    289     else
    290     {
    291       dat = y0;
     311  BDat dat;
     312  BUserTimeSet* dating = Dating();
     313  if(dating && (dating->Inf()<=dte) && (dating->Sup()>=dte))
     314  {
     315    if(d0!=d1)
     316    {
     317      if(y1!=y0)
     318      {
     319        BReal pendient = (y1-y0)/Dating()->Difference(d0, d1);
     320        dat = y0 + pendient*Dating()->Difference(d0, dte);
     321      }
     322      else
     323      {
     324        dat = y0;
     325      }
    292326    }
    293327  }
    … …  
    320354//--------------------------------------------------------------------
    321355{
    322   if(!Dating()) { return(BDat::Unknown()); }
    323   BDat dat;
     356  BDat dat;
     357  BUserTimeSet* dating = Dating();
     358  if(dating && (dating->Inf()<=dte) && (dating->Sup()>=dte) && center_)
    324359  if(center_)
    325360  {
    326     BDate next = dte  + Dating();
     361    BDate next = dte  + dating;
    327362    if(next.HasValue())
    328363    {
    329       BDate prev = next - Dating();
     364      BDate prev = next - dating;
    330365      if(prev.HasValue())
    331366      {
    … …  
    367402//--------------------------------------------------------------------
    368403{
    369   if(!Dating()) { return(BDat::Unknown()); }
    370   BDat dat;
    371   if(center_)
     404  BDat dat;
     405  BUserTimeSet* dating = Dating();
     406  if(dating && (dating->Inf()<=dte) && (dating->Sup()>=dte) && center_)
    372407  {
    373408    dat = center_->Contain(dte);
    … …  
    478513//--------------------------------------------------------------------
    479514{
    480   if(!Dating()||!Ser()||!Ser()->Dating()) { return(BDat::Unknown()); }
    481   BDate dte2 = dte  + Dating() - Ser()->Dating();
    482 
    483   BUserDate* uDte1 = new BContensDate(dte );
    484   BUserDate* uDte2 = new BContensDate(dte2);
    485 
    486   BList* lst = Cons(Ser(),Cons(uDte1,NCons(uDte2)));
    487   BDatStatistic* uDat = (BDatStatistic*)(Stat()->Evaluator(lst));
    488   BDat dat;
    489   if(uDat)
    490   {
    491     dat = uDat->Contens();
    492     DESTROY(uDat);
     515  BDat dat;
     516  BUserTimeSet* dating = Dating();
     517  if(dating && (dating->Inf()<=dte) && (dating->Sup()>=dte) && Ser() && Ser()->Dating())
     518  {
     519    BDate dte2 = dte  + Dating() - Ser()->Dating();
     520    BUserDate* uDte1 = new BContensDate(dte );
     521    BUserDate* uDte2 = new BContensDate(dte2);
     522    BList* lst = Cons(Ser(),Cons(uDte1,NCons(uDte2)));
     523    BDatStatistic* uDat = (BDatStatistic*)(Stat()->Evaluator(lst));
     524    if(uDat)
     525    {
     526      dat = uDat->Contens();
     527      DESTROY(uDat);
     528    }
    493529  }
    494530  return(dat);
    … …  
    548584//--------------------------------------------------------------------
    549585{
    550     if(!Dating()) { return(BDat::Unknown()); }
    551     BDat dat;
     586  BDat dat;
     587  BUserTimeSet* dating = Dating();
     588  if(dating && (dating->Inf()<=dte) && (dating->Sup()>=dte))
     589  {
    552590    if(Ser(1)&&Ser(2))
    553591    {
    554   if(Ser(1)->Dating()->Contain(dte)) { dat = (*Ser(1))[dte]; }
    555   else           { dat = (*Ser(2))[dte]; }
    556     }
    557     return(dat);
     592      if(Ser(1)->Dating()->Contain(dte)) { dat = (*Ser(1))[dte]; }
     593      else                               { dat = (*Ser(2))[dte]; }
     594    }
     595  }
     596  return(dat);
    558597}
    559598
    … …  
    582621{
    583622//InitTotalTime("BTsrExpand::GetDat");
    584   if(!Dating()) { return(BDat::Unknown()); }
    585   BDat dat;
    586   BDat val = 0;
    587   if(Arg(2)) { val = Dat(Arg(2)); }
    588   if(Dating() && (dte>=FirstDate()) && dte<=LastDate())
    589   {
    590     if(Data().HasValue()) { dat = data_[GetIndex(dte)]; }
    591     else
    592     {
    593       BInt n=0;
    594       BDate d=FirstDate();
    595       BDat  lastNotEqual = val;
    596 
    597       GetLength();
    598       Ser()->GetData(data_, FirstDate(),LastDate(),Length());
    599 
    600       BHash hash; Dating()->GetHashBetween(hash, FirstDate(),LastDate());
    601       BReal h = dte.Hash();
    602       for(; n<Length(); n++)
    603       {
    604   if(data_[n]==val)
    605   {
    606     data_[n] = lastNotEqual;
    607   }
    608   else      { lastNotEqual = data_[n];   }
    609   if(hash[n]==h) { dat = data_[n]; }
    610   d+=Dating();
     623  BDat dat;
     624  BUserTimeSet* dating = Dating();
     625  if(dating && (dating->Inf()<=dte) && (dating->Sup()>=dte))
     626  {
     627    BDat val = 0;
     628    if(Arg(2)) { val = Dat(Arg(2)); }
     629    if(Dating() && (dte>=FirstDate()) && dte<=LastDate())
     630    {
     631      if(Data().HasValue()) { dat = data_[GetIndex(dte)]; }
     632      else
     633      {
     634        BInt n=0;
     635        BDate d=FirstDate();
     636        BDat  lastNotEqual = val;
     637        GetLength();
     638        Ser()->GetData(data_, FirstDate(),LastDate(),Length());
     639        BHash hash; Dating()->GetHashBetween(hash, FirstDate(),LastDate());
     640        BReal h = dte.Hash();
     641        for(; n<Length(); n++)
     642        {
     643          if(data_[n]==val)
     644          {
     645            data_[n] = lastNotEqual;
     646          }
     647          else      { lastNotEqual = data_[n];   }
     648          if(hash[n]==h) { dat = data_[n]; }
     649          d+=Dating();
     650        }
    611651      }
    612652    }
    613653  }
    614654//SumPartialTime;
    615 
    616655  return(dat);
    617656}
    … …  
    689728//--------------------------------------------------------------------
    690729{
    691   if(!Dating()) { return(BDat::Unknown()); }
    692   BDat dat;
    693   if((dte>=FirstDate()) && (dte<=LastDate()))
    694   {
    695     if(!IsStochastic())
    696     {
    697       dat =  Ser()->GetDat(dte);
    698     }
    699     else if(Data().HasValue())
    700     {
    701       bool wasTheBegin = false;
    702       if(FirstDate()==BDate::Begin())
    703       {
    704         wasTheBegin = true;
    705         firstDate_ = BDate::DefaultFirst();
    706       }
    707       dat = data_[GetIndex(dte)];
    708       if(wasTheBegin) firstDate_ = BDate::Begin();
    709     }
    710     else
    711     {
    712       GetLength();
    713       Ser()->GetData(data_,FirstDate(),LastDate(),Length());
    714      
    715       BInt n=0;
    716       BDate d = FirstDate();
    717       if(d==BDate::Begin()) d = BDate::DefaultFirst();
    718       BHash hash; Dating()->GetHashBetween(hash, FirstDate(),LastDate());
    719       BReal h = dte.Hash();
    720      
    721       for(; n<hash.Size(); n++)
    722       {
    723         hash[n] = d.Hash();
    724         if(hash[n]==h) { dat = data_[n]; }
    725         d+=Dating();
    726       }
    727       length_ = hash.Size();
    728       CompactData();
     730  BDat dat;
     731  BUserTimeSet* dating = Dating();
     732  if(dating && (dating->Inf()<=dte) && (dating->Sup()>=dte))
     733  {
     734    if((dte>=FirstDate()) && (dte<=LastDate()))
     735    {
     736      if(!IsStochastic())
     737      {
     738        dat =  Ser()->GetDat(dte);
     739      }
     740      else if(Data().HasValue())
     741      {
     742        bool wasTheBegin = false;
     743        if(FirstDate()==BDate::Begin())
     744        {
     745          wasTheBegin = true;
     746          firstDate_ = BDate::DefaultFirst();
     747        }
     748        dat = data_[GetIndex(dte)];
     749        if(wasTheBegin) firstDate_ = BDate::Begin();
     750      }
     751      else
     752      {
     753        GetLength();
     754        Ser()->GetData(data_,FirstDate(),LastDate(),Length());
     755       
     756        BInt n=0;
     757        BDate d = FirstDate();
     758        if(d==BDate::Begin()) d = BDate::DefaultFirst();
     759        BHash hash; Dating()->GetHashBetween(hash, FirstDate(),LastDate());
     760        BReal h = dte.Hash();
     761       
     762        for(; n<hash.Size(); n++)
     763        {
     764          hash[n] = d.Hash();
     765          if(hash[n]==h) { dat = data_[n]; }
     766          d+=Dating();
     767        }
     768        length_ = hash.Size();
     769        CompactData();
     770      }
    729771    }
    730772  }
    … …  
    787829{
    788830//InitTotalTime("BTsrPolyn::GetDat");
    789   if(!Dating()) { return(BDat::Unknown()); }
    790   BDat dat;
    791   if(!Length())
    792   {
    793     dat = 0.0;
    794     for(BInt n = 0; n<pol_.Size(); n++)
    795     {
    796       BDate d = ser_->Dating()->Prev(dte, pol_[n].Degree());
    797       BDat  x = (*ser_)[d];
    798       dat    += pol_[n].Coef()*x;
    799     }
    800   }
    801   else if(Data().HasValue()) { dat = data_[GetIndex(dte)]; }
    802   else if((dte>=firstDate_) && dte<=lastDate_)
    803   {
    804     BData serData;
    805     ser_->GetData(serData);
    806 
    807 
    808     BHash hash; Dating()->GetHashBetween(hash, firstDate_,lastDate_);
    809     Realloc(hash.Size());
    810     BInt  n;
    811     BDate d;
    812     BReal h = dte.Hash();
    813 
    814     for(n=0; n<Length(); n++)
    815     {
    816       data_[n] = 0.0;
    817       for(BInt p = 0; p<pol_.Size(); p++)
    818       {
    819   BInt m    = n-pol_[p].Degree()+backward_;
    820   BDat  x    = serData[m];
    821   data_[n] += pol_[p].Coef()*x;
    822       }
    823       if(hash[n]==h) { dat = data_[n]; }
    824 
    825     }
    826     CompactData();
    827   }
    828 //SumPartialTime;
     831  BDat dat;
     832  BUserTimeSet* dating = Dating();
     833  if(dating && (dating->Inf()<=dte) && (dating->Sup()>=dte))
     834  {
     835    if(!Length())
     836    {
     837      dat = 0.0;
     838      for(BInt n = 0; n<pol_.Size(); n++)
     839      {
     840        BDate d = ser_->Dating()->Prev(dte, pol_[n].Degree());
     841        BDat  x = (*ser_)[d];
     842        dat    += pol_[n].Coef()*x;
     843      }
     844    }
     845    else if(Data().HasValue()) { dat = data_[GetIndex(dte)]; }
     846    else if((dte>=firstDate_) && dte<=lastDate_)
     847    {
     848      BData serData;
     849      ser_->GetData(serData);
     850
     851
     852      BHash hash; Dating()->GetHashBetween(hash, firstDate_,lastDate_);
     853      Realloc(hash.Size());
     854      BInt  n;
     855      BDate d;
     856      BReal h = dte.Hash();
     857
     858      for(n=0; n<Length(); n++)
     859      {
     860        data_[n] = 0.0;
     861        for(BInt p = 0; p<pol_.Size(); p++)
     862        {
     863    BInt m    = n-pol_[p].Degree()+backward_;
     864    BDat  x    = serData[m];
     865    data_[n] += pol_[p].Coef()*x;
     866        }
     867        if(hash[n]==h) { dat = data_[n]; }
     868
     869      }
     870      CompactData();
     871    }
     872  }
     873  //SumPartialTime;
    829874  return(dat);
    830875}
    … …  
    903948{
    904949//nitTotalTime("BTsrDifEq::GetDat");
    905   if(!Dating()) { return(BDat::Unknown()); }
    906   BDat dat;
    907   if(firstDate_.HasValue() && lastDate_.HasValue() &&
    908      (dte>=firstDate_) && (dte<=lastDate_))
    909   {
    910     if(Data().HasValue()) { dat = data_[GetIndex(dte)]; }
    911     else
    912     {
    913       BInt n=0;
    914       BHash hash; Dating()->GetHashBetween(hash, firstDate_,lastDate_);
    915       Realloc(hash.Size());
    916       BReal h0 = ser_->FirstDate().Hash();
    917       BReal h  = dte.Hash();
    918 
    919       for(n=0; (n<Length()) && (hash[n]<h0); n++)
    920       {
    921   data_[n] = (*ini_)[HashToDte(hash[n])];
    922   if(hash[n]==h) { dat = data_[n]; }
    923       }
    924 
    925       for(; n<Length(); n++)
    926       {
    927   data_[n] = (*ser_)[HashToDte(hash[n])];
    928   for(BInt p = 0; p<pol_.Size(); p++)
    929   {
    930     BInt m    = n-pol_[p].Degree();
    931     BDat  x   = data_[m];
    932     data_[n] += pol_[p].Coef()*x;
    933   }
    934   if(hash[n]==h) { dat = data_[n]; }
    935       }
    936       CompactData();
     950  BDat dat;
     951  BUserTimeSet* dating = Dating();
     952  if(dating && (dating->Inf()<=dte) && (dating->Sup()>=dte))
     953  {
     954    if(firstDate_.HasValue() && lastDate_.HasValue() &&
     955       (dte>=firstDate_) && (dte<=lastDate_))
     956    {
     957      if(Data().HasValue()) { dat = data_[GetIndex(dte)]; }
     958      else
     959      {
     960        BInt n=0;
     961        BHash hash; Dating()->GetHashBetween(hash, firstDate_,lastDate_);
     962        Realloc(hash.Size());
     963        BReal h0 = ser_->FirstDate().Hash();
     964        BReal h  = dte.Hash();
     965
     966        for(n=0; (n<Length()) && (hash[n]<h0); n++)
     967        {
     968    data_[n] = (*ini_)[HashToDte(hash[n])];
     969    if(hash[n]==h) { dat = data_[n]; }
     970        }
     971
     972        for(; n<Length(); n++)
     973        {
     974    data_[n] = (*ser_)[HashToDte(hash[n])];
     975    for(BInt p = 0; p<pol_.Size(); p++)
     976    {
     977      BInt m    = n-pol_[p].Degree();
     978      BDat  x   = data_[m];
     979      data_[n] += pol_[p].Coef()*x;
     980    }
     981    if(hash[n]==h) { dat = data_[n]; }
     982        }
     983        CompactData();
     984      }
    937985    }
    938986  }
    … …  
    10171065//--------------------------------------------------------------------
    10181066{
    1019   if(!Dating()) { return(BDat::Unknown()); }
    1020   if(!LeftSer() || !RightSer()) { return(BDat::Unknown()); }
    1021   if(dte<=Center())    { return((*LeftSer()) [dte]); }
    1022   else        { return((*RightSer())[dte]); }
     1067  BDat dat;
     1068  BUserTimeSet* dating = Dating();
     1069  if(dating && (dating->Inf()<=dte) && (dating->Sup()>=dte))
     1070  {
     1071    if(!LeftSer() || !RightSer()) { return(BDat::Unknown()); }
     1072    if(dte<=Center())    { return((*LeftSer()) [dte]); }
     1073    else        { return((*RightSer())[dte]); }
     1074  }
     1075  return(dat);
    10231076}
    10241077
    … …  
    10601113//--------------------------------------------------------------------
    10611114{
    1062   if(!Dating()) { return(BDat::Unknown()); }
    1063   if(!LeftSer() || !RightSer())     { return(BDat::Unknown()); }
    1064   if(dte>=RightSer()->FirstDate()) { return((*RightSer())[dte]); }
    1065   else           { return((*LeftSer ())[dte]); }
     1115  BDat dat;
     1116  BUserTimeSet* dating = Dating();
     1117  if(dating && (dating->Inf()<=dte) && (dating->Sup()>=dte))
     1118  {
     1119    if(!Dating()) { return(BDat::Unknown()); }
     1120    if(!LeftSer() || !RightSer())     { return(BDat::Unknown()); }
     1121    if(dte>=RightSer()->FirstDate()) { return((*RightSer())[dte]); }
     1122    else           { return((*LeftSer ())[dte]); }
     1123  }
     1124  return(dat);
    10661125}
    10671126
    … …  
    11031162//--------------------------------------------------------------------
    11041163{
    1105   if(!Dating()) { return(BDat::Unknown()); }
    1106   if(!LeftSer() || !RightSer())   { return(BDat::Unknown()); }
    1107   if(dte<=LeftSer()->LastDate()) { return((*LeftSer ())[dte]); }
    1108   else         { return((*RightSer())[dte]); }
     1164  BDat dat;
     1165  BUserTimeSet* dating = Dating();
     1166  if(dating && (dating->Inf()<=dte) && (dating->Sup()>=dte))
     1167  {
     1168    if(!Dating()) { return(BDat::Unknown()); }
     1169    if(!LeftSer() || !RightSer())   { return(BDat::Unknown()); }
     1170    if(dte<=LeftSer()->LastDate()) { return((*LeftSer ())[dte]); }
     1171    else         { return((*RightSer())[dte]); }
     1172  }
     1173  return(dat);
    11091174}
    11101175
    … …  
    11481213//--------------------------------------------------------------------
    11491214{
    1150   if(!Dating()) { return(BDat::Unknown()); }
    1151   BDat dat;
    1152   if(Data().HasValue()) { dat = data_[GetIndex(dte)]; }
    1153   else
    1154   {
    1155     BInt len = GetLength();
    1156     Realloc(len);
    1157     BDate d;
    1158     BInt  n;
    1159     BInt  ind=-1;
    1160     BData expand(len);
    1161     BPol  p  = rat_ % (len-1);
    1162     BHash hash; Dating()->GetHashBetween(hash, FirstDate(),LastDate());
    1163     BReal h = dte.Hash();
    1164   //Std("\nExpansion = ");
    1165     for(n=0; n<len; n++)
    1166     {
    1167       expand[n] = p.Coef(n);
    1168       data_[n]=(*ser_)[HashToDte(hash[n])];
    1169     //Std(expand[n].Name());
    1170     //Std(data_[n].Name());
    1171     }
    1172     for(n=0; n<len; n++)
    1173     {
    1174     //Std(BText("\nOmmit[")+d+"]="+(*ommit_)[d]);
    1175       if((*ommit_)[d]!=0)
    1176       {
    1177         BDat pivot = data_[n];
    1178         for(BInt m=n; m<Length(); m++)
     1215  BDat dat;
     1216  BUserTimeSet* dating = Dating();
     1217  if(dating && (dating->Inf()<=dte) && (dating->Sup()>=dte))
     1218  {
     1219    if(Data().HasValue()) { dat = data_[GetIndex(dte)]; }
     1220    else
     1221    {
     1222      BInt len = GetLength();
     1223      Realloc(len);
     1224      BDate d;
     1225      BInt  n;
     1226      BInt  ind=-1;
     1227      BData expand(len);
     1228      BPol  p  = rat_ % (len-1);
     1229      BHash hash; Dating()->GetHashBetween(hash, FirstDate(),LastDate());
     1230      BReal h = dte.Hash();
     1231    //Std("\nExpansion = ");
     1232      for(n=0; n<len; n++)
     1233      {
     1234        expand[n] = p.Coef(n);
     1235        data_[n]=(*ser_)[HashToDte(hash[n])];
     1236      //Std(expand[n].Name());
     1237      //Std(data_[n].Name());
     1238      }
     1239      for(n=0; n<len; n++)
     1240      {
     1241      //Std(BText("\nOmmit[")+d+"]="+(*ommit_)[d]);
     1242        if((*ommit_)[d]!=0)
    11791243        {
    1180           data_[m] -= expand[m-n]*pivot;
     1244          BDat pivot = data_[n];
     1245          for(BInt m=n; m<Length(); m++)
     1246          {
     1247            data_[m] -= expand[m-n]*pivot;
     1248          }
     1249      //Std(BText("\ndata_[")+n+"]="+data_[n].Name());
    11811250        }
    1182     //Std(BText("\ndata_[")+n+"]="+data_[n].Name());
    1183       }
    1184       if(hash[n]==h) { ind = n; }
    1185     }
    1186     if(ind>=0) { dat = data_[ind]; }
    1187   }
    1188   return(dat);
    1189 }
     1251        if(hash[n]==h) { ind = n; }
     1252      }
     1253      if(ind>=0) { dat = data_[ind]; }
     1254    }
     1255  }
     1256  return(dat);
     1257}
Note: See TracChangeset for help on using the changeset viewer.