Changeset 3f203ae in tol


Ignore:
Timestamp:
Aug 3, 2012, 9:06:37 AM (14 years ago)
Author:
Víctor de Buen <vdebuen@…>
Branches:
1941-docker-image-to-test, devel, master
Children:
d35ce02
Parents:
fb55369
Message:

Refs #1136
Box-Pierce-Ljung statistic

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

Location:
tol
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • tol/bmath/bstat/stat.cpp

    rfb55369 r3f203ae  
    10301030
    10311031//--------------------------------------------------------------------
    1032 BDat BoxPierceLjung(const BArray<BDat>& vec, BInt m, BInt p, BInt q)
    1033 
    1034 /*! Returns the Box-Pierce-Ljung statistic of a vector with m
    1035  *  autocorrelations, p AR-parameters and q MA-parameters
    1036  */
    1037 //--------------------------------------------------------------------
    1038 {
    1039     BInt k, N = vec.Size();
    1040     BDat Q = 0;
    1041     BArray<BDat> cor;
    1042     AutoCor(vec,cor,m);
    1043     for(k = 0; k<m; k++) { Q += ((cor(k)^2)/BDat(N-k-1)); }
    1044     Q *= BDat(N*(N+2));
    1045     return(Q);
     1032BDat BoxPierceLjungACF(const BArray<BDat>& acf, BInt s, BInt m)
     1033
     1034/*! Returns the Box-Pierce-Ljung statistic for first m autocorrelations
     1035 *  of a time series of length s
     1036 */
     1037//--------------------------------------------------------------------
     1038{
     1039  BDat Q = 0;
     1040  BInt k;
     1041  if(m>acf.Size()) { m=acf.Size(); }
     1042  for(k=0; k<m; k++)
     1043  {
     1044    Q += ((acf(k)^2)/BDat(s-k-1));
     1045  }
     1046  Q *= BDat(s*(s+2));
     1047  return(Q);
     1048}
     1049
     1050
     1051//--------------------------------------------------------------------
     1052BDat BoxPierceLjung(const BArray<BDat>& vec, BInt m)
     1053
     1054/*! Returns the Box-Pierce-Ljung statistic for first m autocorrelations
     1055 *  of a time series vec.
     1056 */
     1057//--------------------------------------------------------------------
     1058{
     1059  BInt s = vec.Size();
     1060  BArray<BDat> acf;
     1061  AutoCor(vec,acf,m);
     1062  return(BoxPierceLjungACF(acf,m,s));
    10461063}
    10471064
  • tol/bmath/bstat/tol_bstat.h

    rfb55369 r3f203ae  
    8888TOL_API void InvPartAutoCor       (const BArray<BDat>& cor,
    8989                                         BArray<BDat>& p);
    90 TOL_API BDat BoxPierceLjung       (const BArray<BDat>& vec,
    91                                                      BInt m, BInt p, BInt q);
     90TOL_API BDat BoxPierceLjung       (const BArray<BDat>& vec, BInt m);
     91TOL_API BDat BoxPierceLjungACF    (const BArray<BDat>& acf, BInt m, BInt s);
    9292
    9393//! To obtine the exponent of the best Box-Cox exponential transformation of a
  • tol/btol/real_type/datgsrst.cpp

    rfb55369 r3f203ae  
    2727#include <tol/tol_bsetgra.h>
    2828#include <tol/tol_bdtegra.h>
     29#include <tol/tol_bmatgra.h>
    2930#include <tol/tol_bout.h>
    3031#include <tol/tol_btsrgrp.h>
    3132#include <tol/tol_bstat.h>
    3233#include <tol/tol_btest.h>
    33 
    34 #ifdef __USE_TC__
    35 #  include <tol/tol_bctsrgrav.h>
    36 #endif
    3734
    3835//--------------------------------------------------------------------
    … …  
    9289}
    9390
    94 #ifdef __USE_TC__
    95 //--------------------------------------------------------------------
    96 BDatCStatistic::BDatCStatistic(BList* arg)
    97     : BDatTemporary(arg), cser_(Arg(1))
    98 {
    99     if(arg)
    100     {
    101         if(Arg(2)) { ini_ = CTime(Arg(2)); }
    102 
    103         if(!ini_.isNormal() || (ini_<CTsrR(cser_).FirstCTime()))
    104         { ini_=CTsrR(cser_).FirstCTime(); }
    105        
    106         if(!ini_.isNormal())
    107         {
    108             ini_ = BCTime::fillNew(CTsrR(cser_).Dating()->getGranul(),
    109                                    LV, 1, BCTime::Now().year());
    110         }
    111        
    112         if(Arg(3)) { fin_ = CTime(Arg(3)); }
    113        
    114         if(!fin_.isNormal() || (fin_>CTsrR(cser_).LastCTime()))
    115         { fin_ = CTsrR(cser_).LastCTime(); }
    116        
    117         if(!fin_.isNormal())
    118         {
    119             fin_ = BCTime::fillNew(CTsrR(cser_).Dating()->getGranul(),
    120                                    HV, 1, BCTime::Now().year());
    121         }
    122     }
    123 
    124     PutArgs(cser_, ini_, fin_);
    125 }
    126 
    127 //--------------------------------------------------------------------
    128 void BDatCStatistic::PutArgs(BSyntaxObject* cser,
    129                              const BCTime& ini,
    130                              const BCTime& fin)
    131 {
    132     if(!cser) { return; }
    133 
    134     cser_ = cser;
    135     BUserCTimeSeries* cseries = CTsr(cser_);
    136     if(!cseries->Dating()) { return; }
    137 
    138     if(cser && cseries->Dating())
    139     {
    140         ini_ = cseries->Dating()->nonSmaller(ini);
    141         fin_ = fin;
    142         cseries->GetData(vec_, ini_, fin_);
    143     }
    144 }
    145 #endif // __USE_TC__
    14691
    14792//--------------------------------------------------------------------
    … …  
    167112}
    168113
    169 #ifdef __USE_TC__
    170 //--------------------------------------------------------------------
    171 DefExtOpr(1, BDatCStatFirst, "CFirstS", 1, 3, "CSeries CTime CTime",
    172           I2("(CSeries ser [, CTime from, CTime until])",
    173              "(CSeries ser [, CTime desde, CTime hasta])"),
    174           I2("Returns the first value of a serie between two dates. "
    175              "If they do not appear, it is assumed the calculation with the "
    176              "first and last dates of the series. Finally, if the series "
    177              "lacks dates, is calculated with the dates by defect.",
    178              "Devuelve el primer valor de una serie entre dos fechas. "
    179              "Si no aparecen, se asume el cálculo con las fechas primera "
    180              "y última de la serie. Por último, si la serie carece de fechas, "
    181              "se calcula con las fechas por defecto."),
    182           BOperClassify::Statistic_);
    183 //--------------------------------------------------------------------
    184 void BDatCStatFirst::CalcContens()
    185 {
    186     if(cser_ && CTsrR(cser_).Dating())
    187     {
    188         contens_ = vec_[0];
    189     }
    190 }
    191 #endif // __USE_TC__
    192114
    193115//--------------------------------------------------------------------
    … …  
    212134  }
    213135}
    214 
    215 #ifdef __USE_TC__
    216 //--------------------------------------------------------------------
    217 DefExtOpr(1, BDatCStatLast, "CLastS", 1, 3, "CSeries CTime CTime",
    218           I2("(CSeries cser [, CTime from, CTime until])",
    219              "(CSeries cser [, CTime desde, CTime hasta])"),
    220           I2("Returns the last value of a serie between two dates. If they "
    221              "do not appear, it is assumed the calculation with the first "
    222              "and last dates of the series. Finally, if the series lacks "
    223              "dates, is calculated with the dates by defect.",
    224              "Devuelve el último valor de una serie entre dos fechas. "
    225              "Si no aparecen, se asume el cálculo con las fechas primera "
    226              "y última de la serie. Por último, si la serie carece de fechas, "
    227              "se calcula con las fechas por defecto."),
    228           BOperClassify::Statistic_);
    229 //--------------------------------------------------------------------
    230 void BDatCStatLast::CalcContens()
    231 {
    232     if(cser_ && CTsrR(cser_).Dating())
    233     {
    234         contens_ = vec_[vec_.Size()-1];
    235     }
    236 }
    237 #endif // __USE_TC__
    238136
    239137//--------------------------------------------------------------------
    … …  
    266164}
    267165
    268 #ifdef __USE_TC__
    269 //--------------------------------------------------------------------
    270 DefExtOpr(1, BDatCStatCount, "CCountS", 1, 3, "CSeries CTime CTime",
    271           I2("(CSeries cser [, CTime from, CTime until])",
    272              "(CSeries cser [, CTime desde, CTime hasta])"),
    273           I2("Returns the dates number of a serie between two dates. If they "
    274              "do not appear, it is assumed the calculation with the first "
    275              "and last dates of the series. Finally, if the series lacks "
    276              "dates, is calculated with the dates by defect. ",
    277              "Devuelve el número de datos de una serie entre dos fechas. "
    278              "Si no aparecen, se asume el cálculo con las fechas primera "
    279              "y última de la serie. Por último, si la serie carece de fechas, "
    280              "se calcula con las fechas por defecto."),
    281           BOperClassify::Statistic_);
    282 //--------------------------------------------------------------------
    283 void BDatCStatCount::CalcContens()
    284 {
    285     if(cser_ && CTsrR(cser_).Dating())
    286     {
    287         contens_ = vec_.Size();
    288     }
    289 }
    290 #endif // __USE_TC__
    291 
    292166//--------------------------------------------------------------------
    293167  DefExtOpr(1, BDatStatMax,     "MaxS", 1, 3, "Serie Date Date",
    … …  
    312186}
    313187
    314 #ifdef __USE_TC__
    315 //--------------------------------------------------------------------
    316 DefExtOpr(1, BDatCStatMax, "CMaxS", 1, 3, "CSeries CTime CTime",
    317           I2("(CSeries cser [, CTime from, CTime until])",
    318              "(CSeries cser [, CTime desde, CTime hasta])"),
    319           I2("Returns the maximum value of a serie between two dates. If they "
    320              "do not appear, it is assumed the calculation with the first "
    321              "and last dates of the series. Finally, if the series lacks "
    322              "dates, is calculated with the dates by defect.",
    323              "Devuelve el máximo valor de una serie entre dos fechas. "
    324              "Si no aparecen, se asume el cálculo con las fechas primera "
    325              "y última de la serie. Por último, si la serie carece de fechas, "
    326              "se calcula con las fechas por defecto."),
    327           BOperClassify::Statistic_);
    328 //--------------------------------------------------------------------
    329 void BDatCStatMax::CalcContens()
    330 {
    331     if(cser_ && CTsrR(cser_).Dating())
    332     {
    333         contens_ = Maximum(vec_);
    334     }
    335 }
    336 #endif // __USE_TC__
    337188
    338189//--------------------------------------------------------------------
    … …  
    358209}
    359210
    360 #ifdef __USE_TC__
    361 //--------------------------------------------------------------------
    362 DefExtOpr(1, BDatCStatMin, "CMinS", 1, 3, "CSeries CTime CTime",
    363           I2("(CSeries cser [, CTime from, CTime until])",
    364              "(CSeries cser [, CTime desde, CTime hasta])"),
    365           I2("Returns the minimum value of a serie between two dates. If they "
    366              "do not appear, it is assumed the calculation with the first "
    367              "and last dates of the series. Finally, if the series lacks "
    368              "dates, is calculated with the dates by defect.",
    369              "Devuelve el mínimo valor de una serie entre dos fechas. "
    370              "Si no aparecen, se asume el cálculo con las fechas primera "
    371              "y última de la serie. Por último, si la serie carece de fechas, "
    372              "se calcula con las fechas por defecto."),
    373           BOperClassify::Statistic_);
    374 //--------------------------------------------------------------------
    375 void BDatCStatMin::CalcContens()
    376 {
    377     if(cser_ && CTsrR(cser_).Dating())
    378     {
    379         contens_ = Minimum(vec_);
    380     }
    381 }
    382 #endif // __USE_TC__
    383211
    384212//--------------------------------------------------------------------
    … …  
    404232}
    405233
    406 #ifdef __USE_TC__
    407 //--------------------------------------------------------------------
    408 DefExtOpr(1, BDatCStatSum, "CSumS", 1, 3, "CSeries CTime CTime",
    409           I2("(CSeries cser [, CTime from, CTime until])",
    410              "(CSeries cser [, CTime desde, CTime hasta])"),
    411           I2("Returns the sum of a serie between two dates. If they do not "
    412              "appear, it is assumed the calculation with the first and "
    413              "last dates of the series. Finally, if the series lacks "
    414              "dates, is calculated with the dates by defect.",
    415              "Devuelve la suma de una serie entre dos fechas. "
    416              "Si no aparecen, se asume el cálculo con las fechas primera "
    417              "y última de la serie. Por último, si la serie carece de fechas, "
    418              "se calcula con las fechas por defecto."),
    419           BOperClassify::Statistic_);
    420 //--------------------------------------------------------------------
    421 void BDatCStatSum::CalcContens()
    422 {
    423     if(cser_ && CTsrR(cser_).Dating())
    424     {
    425         contens_ = Sum(vec_);
    426     }
    427 }
    428 #endif // __USE_TC__
    429 
    430234//--------------------------------------------------------------------
    431235  DefExtOpr(1, BDatStatAverage, "AvrS",   1, 3, "Serie Date Date",
    … …  
    450254}
    451255
    452 #ifdef __USE_TC__
    453 //--------------------------------------------------------------------
    454 DefExtOpr(1, BDatCStatAverage, "CAvrS", 1, 3, "CSeries CTime CTime",
    455           I2("(CSeries cser [, CTime from, CTime until])",
    456              "(CSeries cser [, CTime desde, CTime hasta])"),
    457           I2("Returns the average of a serie between two dates. If they do "
    458              "not appear, it is assumed the calculation with the first and "
    459              "last dates of the series. Finally, if the series lacks "
    460              "dates, is calculated with the dates by defect.",
    461              "Devuelve la media de una serie entre dos fechas. "
    462              "Si no aparecen, se asume el cálculo con las fechas primera "
    463              "y última de la serie. Por último, si la serie carece de fechas, "
    464              "se calcula con las fechas por defecto."),
    465           BOperClassify::Statistic_);
    466 //--------------------------------------------------------------------
    467 void BDatCStatAverage::CalcContens()
    468 {
    469     if(cser_ && CTsrR(cser_).Dating())
    470     {
    471         contens_ = Average(vec_);
    472     }
    473 }
    474 #endif // __USE_TC__
    475256
    476257//--------------------------------------------------------------------
    … …  
    496277}
    497278
    498 #ifdef __USE_TC__
    499 //--------------------------------------------------------------------
    500 DefExtOpr(1, BDatCStatVarianze,"CVarS", 1, 3, "CSeries CTime CTime",
    501           I2("(CSeries cser [, CTime from, CTime until])",
    502              "(CSeries cser [, CTime desde, CTime hasta])"),
    503           I2("Returns the varianze of a serie between two dates. If they do "
    504              "not appear, it is assumed the calculation with the first and "
    505              "last dates of the series. Finally, if the series lacks "
    506              "dates, is calculated with the dates by defect.",
    507              "Devuelve la varianza de una serie entre dos fechas. "
    508              "Si no aparecen, se asume el cálculo con las fechas primera "
    509              "y última de la serie. Por último, si la serie carece de fechas, "
    510              "se calcula con las fechas por defecto."),
    511           BOperClassify::Statistic_);
    512 //--------------------------------------------------------------------
    513 void BDatCStatVarianze::CalcContens()
    514 {
    515     if(cser_ && CTsrR(cser_).Dating())
    516     {
    517         contens_ = Varianze(vec_);
    518     }
    519 }
    520 #endif // __USE_TC__
    521279
    522280//--------------------------------------------------------------------
    … …  
    542300}
    543301
    544 #ifdef __USE_TC__
    545 //--------------------------------------------------------------------
    546 DefExtOpr(1, BDatCStatStDs, "CStDsS", 1, 3, "CSeries CTime CTime",
    547           I2("(CSeries cser [, CTime from, CTime until])",
    548              "(CSeries cser [, CTime desde, CTime hasta])"),
    549           I2("Returns the standard deviation of a serie between two dates. If "
    550              "they do not appear, it is assumed the calculation with the first"
    551              " and last dates of the series. Finally, if the series lacks "
    552              "dates, is calculated with the dates by defect.",
    553              "Devuelve la desviación tipica de una serie entre dos fechas. "
    554              "Si no aparecen, se asume el cálculo con las fechas primera "
    555              "y última de la serie. Por último, si la serie carece de fechas, "
    556              "se calcula con las fechas por defecto."),
    557           BOperClassify::Statistic_);
    558 //--------------------------------------------------------------------
    559 void BDatCStatStDs::CalcContens()
    560 {
    561     if(cser_ && CTsrR(cser_).Dating())
    562     {
    563         contens_ = StandardDeviation(vec_);
    564     }
    565 }
    566 #endif
    567302
    568303//--------------------------------------------------------------------
    … …  
    590325}
    591326
    592 #ifdef __USE_TC__
    593 //--------------------------------------------------------------------
    594 DefExtOpr(1, BDatCStatSubSampleAverage, "CSubSampleAvrS",
    595           1, 3, "CSeries CTime CTime",
    596           I2("(CSeries cser [, CTime from, CTime until])",
    597              "(CSeries cser [, CTime desde, CTime hasta])"),
    598           I2("Returns the average of a serie filtered by anomalies greater "
    599              "than 3 sigmas between two dates. If they do not appear, it is "
    600              "assumed the calculation with the first and last dates of the "
    601              "series. Finally, if the series lacks dates, is calculated "
    602              "with the dates by defect.",
    603              "Devuelve la media filtrada de anómalos mayores de 3 sigmas de "
    604              "una serie entre dos fechas. "
    605              "Si no aparecen, se asume el cálculo con las fechas primera "
    606              "y última de la serie. Por último, si la serie carece de fechas, "
    607              "se calcula con las fechas por defecto."),
    608           BOperClassify::Statistic_);
    609 //--------------------------------------------------------------------
    610 void BDatCStatSubSampleAverage::CalcContens()
    611 {
    612     if(cser_ && CTsrR(cser_).Dating())
    613     {
    614         contens_ = SubSampleAverage(Average,vec_);
    615     }
    616 }
    617 #endif // __USE_TC__
    618 
    619327//--------------------------------------------------------------------
    620328  DefExtOpr(1, BDatStatSubSampleVarianze,"SubSampleVarS",   1, 3, "Serie Date Date",
    … …  
    641349}
    642350
    643 #ifdef __USE_TC__
    644 //--------------------------------------------------------------------
    645 DefExtOpr(1, BDatCStatSubSampleVarianze,"CSubSampleVarS",
    646           1, 3, "CSeries CTime CTime",
    647           I2("(CSeries cser [, CTime from, CTime until])",
    648              "(CSeries cser [, CTime desde, CTime hasta])"),
    649           I2("Returns the varianze of a serie filtered by anomalies greater "
    650              "than 3 sigmas between two dates. If they do not appear, it is "
    651              "assumed the calculation with the first and last dates of the "
    652              "series. Finally, if the series lacks dates, is calculated with "
    653              "the dates by defect.",
    654              "Devuelve la varianza filtrada de anómalos mayores de 3 sigmas "
    655              "de una serie entre dos fechas. Si no aparecen, se asume el "
    656              "cálculo con las fechas primera y última de la serie. Por "
    657              "último, si la serie carece de fechas, se calcula con las "
    658              "fechas por defecto."),
    659           BOperClassify::Statistic_);
    660 //--------------------------------------------------------------------
    661 void BDatCStatSubSampleVarianze::CalcContens()
    662 {
    663     if(cser_ && CTsrR(cser_).Dating())
    664     {
    665         contens_ = SubSampleAverage(Varianze,vec_);
    666     }
    667 }
    668 #endif // __USE_TC__
    669351
    670352//--------------------------------------------------------------------
    … …  
    692374}
    693375
    694 #ifdef __USE_TC__
    695 //--------------------------------------------------------------------
    696 DefExtOpr(1, BDatCStatSubSampleStDs, "CSubSampleStDsS",
    697           1, 3, "CSeries CTime CTime",
    698           I2("(CSeries cser [, CTime from, CTime until])",
    699              "(CSeries cser [, CTime desde, CTime hasta])"),
    700           I2("Returns the standard deviation of a serie filtered by "
    701              "anomalies greater than 3 sigmas between two dates. If they "
    702              "do not appear, it is assumed the calculation with the first "
    703              "and last dates of the series. Finally, if the series lacks "
    704              "dates, is calculated with the dates by defect.",
    705              "Devuelve la desviación tipica filtrada de anómalos mayores "
    706              "de 3 sigmas de una serie entre dos fechas. Si no aparecen, "
    707              "se asume el cálculo con las fechas primera y última de la "
    708              "serie. Por último, si la serie carece de fechas, "
    709              "se calcula con las fechas por defecto."),
    710           BOperClassify::Statistic_);
    711 //--------------------------------------------------------------------
    712 void BDatCStatSubSampleStDs::CalcContens()
    713 {
    714     if(cser_ && CTsrR(cser_).Dating())
    715     {
    716         contens_ = Sqrt(SubSampleAverage(Varianze,vec_));
    717     }
    718 }
    719 #endif // __USE_TC__
    720376
    721377//--------------------------------------------------------------------
    … …  
    741397}
    742398
    743 #ifdef __USE_TC__
    744 //--------------------------------------------------------------------
    745 DefExtOpr(1, BDatCStatAsimetry, "CAsimetryS", 1, 3, "CSeries CTime CTime",
    746           I2("(CSeries cser [, CTime from, CTime until])",
    747              "(CSeries cser [, CTime desde, CTime hasta])"),
    748           I2("Returns the asymmetry coefficient of a serie between two dates. "
    749              "If they do not appear, it is assumed the calculation with the "
    750              "first and last dates of the series. Finally, if the series "
    751              "lacks dates, is calculated with the dates by defect.",
    752              "Devuelve el coeficiente de asimetría de una serie entre dos "
    753              "fechas. Si no aparecen, se asume el cálculo con las fechas "
    754              "primera y última de la serie. Por último, si la serie carece "
    755              "de fechas, se calcula con las fechas por defecto."),
    756           BOperClassify::Statistic_);
    757 //--------------------------------------------------------------------
    758 void BDatCStatAsimetry::CalcContens()
    759 {
    760     if(cser_ && CTsrR(cser_).Dating())
    761     {
    762         contens_ = AsymmetryCoefficient(vec_);
    763     }
    764 }
    765 #endif // __USE_TC__
    766399
    767400//--------------------------------------------------------------------
    … …  
    787420}
    788421
    789 #ifdef __USE_TC__
    790 //--------------------------------------------------------------------
    791 DefExtOpr(1, BDatCStatKurtosis, "CKurtosisS", 1, 3, "CSeries CTime CTime",
    792           I2("(CSeries cser [, CTime from, CTime until])",
    793              "(CSeries cser [, CTime desde, CTime hasta])"),
    794           I2("Returns the kurtosis of a serie between two dates. If they do "
    795              "not appear, it is assumed the calculation with the first and "
    796              "last dates of the series. Finally, if the series lacks dates, "
    797              "is calculated with the dates by defect.",
    798              "Devuelve el coeficiente de curtosis de una serie entre dos "
    799              "fechas. Si no aparecen, se asume el cálculo con las fechas "
    800              "primera y última de la serie. Por último, si la serie carece "
    801              "de fechas, se calcula con las fechas por defecto."),
    802           BOperClassify::Statistic_);
    803 //--------------------------------------------------------------------
    804 void BDatCStatKurtosis::CalcContens()
    805 {
    806     if(cser_ && CTsrR(cser_).Dating())
    807     {
    808         contens_ = Kurtosis(vec_);
    809     }
    810 }
    811 #endif // __USE_TC__
    812422
    813423//--------------------------------------------------------------------
    … …  
    833443}
    834444
    835 #ifdef __USE_TC__
    836 //--------------------------------------------------------------------
    837 DefExtOpr(1, BDatCStatMedian, "CMedianS", 1, 3, "CSeries CTime CTime",
    838           I2("(CSeries cser [, CTime from, CTime until])",
    839              "(CSeries cser [, CTime desde, CTime hasta])"),
    840           I2("Returns the median of a serie between two dates. If they do "
    841              "not appear, it is assumed the calculation with the first and "
    842              "last dates of the series. Finally, if the series lacks dates, "
    843              "is calculated with the dates by defect.",
    844              "Devuelve la mediana de una serie entre dos fechas. "
    845              "Si no aparecen, se asume el cálculo con las fechas primera "
    846              "y última de la serie. Por último, si la serie carece de fechas, "
    847              "se calcula con las fechas por defecto."),
    848           BOperClassify::Statistic_);
    849 //--------------------------------------------------------------------
    850 void BDatCStatMedian::CalcContens()
    851 {
    852     if(cser_ && CTsrR(cser_).Dating())
    853     {
    854         contens_ = Median(vec_);
    855     }
    856 }
    857 #endif // __USE_TC__
    858445
    859446//--------------------------------------------------------------------
    … …  
    876463}
    877464
    878 #ifdef __USE_TC__
    879 //--------------------------------------------------------------------
    880 DefExtOpr(1, BDatCStatQuantile, "CQuantileS",  4, 4,
    881           "CSeries CTime CTime Real",
    882           I2("(CSeries cser, CTime from, CTime until, Real p)",
    883              "(CSeries cser, CTime desde, CTime hasta, Real p)"),
    884           I2("Returns the quantile of a given probability of a serie "
    885              "between two CTimes. ",
    886              "Devuelve el cuantil de probabilidad p de una serie entre dos "
    887              "CTimes. "),
    888           BOperClassify::Statistic_);
    889 //--------------------------------------------------------------------
    890 void BDatCStatQuantile::CalcContens()
    891 {
    892     if(cser_ && CTsrR(cser_).Dating())
    893     {
    894         BDat q   = Dat(Arg(4));
    895         contens_ = Quantile(vec_,q);
    896     }
    897 }
    898 #endif // __USE_TC__
    899 
    900465//--------------------------------------------------------------------
    901466  DefExtOpr(1, BDatStatMoment,    "MomentS",  4, 4, "Serie Date Date Real",
    … …  
    915480}
    916481
    917 #ifdef __USE_TC__
    918 //--------------------------------------------------------------------
    919 DefExtOpr(1, BDatCStatMoment, "CMomentS", 4, 4, "CSeries CTime CTime Real",
    920           I2("(CSeries cser, CTime from, CTime until, Real n)",
    921              "(CSeries cser, CTime desde, CTime hasta, Real n)"),
    922           I2("Returns the moment of a given order of a series between two "
    923              "CTimes. ",
    924              "Devuelve el momento de orden n de una serie entre dos CTimes."),
    925           BOperClassify::Statistic_);
    926 //--------------------------------------------------------------------
    927 void BDatCStatMoment::CalcContens()
    928 {
    929     if(cser_ && CTsrR(cser_).Dating())
    930     {
    931         BInt  m  = (BInt)Real(Arg(4));
    932         contens_ = Moment(vec_,m);
    933     }
    934 }
    935 #endif // _USE_TC__
    936 
    937482//--------------------------------------------------------------------
    938483  DefExtOpr(1,BDatStatCenterMoment,"CenterMomentS",4,4,"Serie Date Date Real",
    … …  
    951496  }
    952497}
    953 
    954 #ifdef __USE_TC__
    955 //--------------------------------------------------------------------
    956 DefExtOpr(1, BDatCStatCenterMoment, "CCenterMomentS", 4, 4,
    957           "CSeries CTime CTime Real",
    958           I2("(CSeries cser, CTime from, CTime until, Real n)",
    959              "(CSeries cser, CTime desde, CTime hasta, Real n)"),
    960           I2("Returns the center moment of a given order of a series between "
    961              "two CTimes.", "Devuelve el momento centrado de orden n de "
    962              "una serie entre dos CTimes."),
    963           BOperClassify::Statistic_);
    964 //--------------------------------------------------------------------
    965 void BDatCStatCenterMoment::CalcContens()
    966 {
    967     if(cser_ && CTsrR(cser_).Dating())
    968     {
    969         BInt  m  = (BInt)Real(Arg(4));
    970         contens_ = CenterMoment(vec_,m);
    971     }
    972 }
    973 #endif // __USE_TC__
    974498
    975499//--------------------------------------------------------------------
    … …  
    1029553    return(mom.Contens());
    1030554}
    1031 
    1032555BDat StatQuantile(BSyntaxObject* ser, BDat q)
    1033556{
    … …  
    1040563}
    1041564
    1042 #ifdef __USE_TC__
    1043 //--------------------------------------------------------------------
    1044 BDat CStatFirst(BSyntaxObject* cser)
    1045 { return(BDatCStatFirst (NCons(cser)).Contens()); }
    1046 
    1047 BDat CStatLast(BSyntaxObject* cser)
    1048 { return(BDatCStatLast (NCons(cser)).Contens()); }
    1049 
    1050 BDat CStatCount(BSyntaxObject* cser)
    1051 { return(BDatCStatCount (NCons(cser)).Contens()); }
    1052 
    1053 BDat CStatMax(BSyntaxObject* cser)
    1054 { return(BDatCStatMax (NCons(cser)).Contens()); }
    1055 
    1056 BDat CStatMin(BSyntaxObject* cser)
    1057 { return(BDatCStatMin (NCons(cser)).Contens()); }
    1058 
    1059 BDat CStatSum(BSyntaxObject* cser)
    1060 { return(BDatCStatSum (NCons(cser)).Contens()); }
    1061 
    1062 BDat CStatAverage(BSyntaxObject* cser)
    1063 { return(BDatCStatAverage (NCons(cser)).Contens()); }
    1064 
    1065 BDat CStatStDs(BSyntaxObject* cser)
    1066 { return(BDatCStatStDs (NCons(cser)).Contens()); }
    1067 
    1068 BDat CStatVarianze(BSyntaxObject* cser)
    1069 { return(BDatCStatVarianze (NCons(cser)).Contens()); }
    1070 
    1071 BDat CStatAsimetry(BSyntaxObject* cser)
    1072 { return(BDatCStatAsimetry (NCons(cser)).Contens()); }
    1073 
    1074 BDat CStatKurtosis(BSyntaxObject* cser)
    1075 { return(BDatCStatKurtosis (NCons(cser)).Contens()); }
    1076 
    1077 BDat CStatMedian(BSyntaxObject* cser)
    1078 { return(BDatCStatMedian (NCons(cser)).Contens()); }
    1079 
    1080 BDat CStatMoment(BSyntaxObject* cser, int order)
    1081 {
    1082     BUserDat*   d  = new BContensDat(BDat(order));
    1083     BUserCTime* f  = new BContensCTime(CTsr(cser)->FirstCTime());
    1084     BUserCTime* l  = new BContensCTime(CTsr(cser)->LastCTime());
    1085     BList*       arg = LstStack(NIL,cser,f,l,d,NIL);
    1086     BDatStatMoment mom(arg);
    1087     return(mom.Contens());
    1088 }
    1089 
    1090 BDat CStatCenterMoment(BSyntaxObject* cser, int order)
    1091 {
    1092     BUserDat*  d   = new BContensDat(BDat(order));
    1093     BUserCTime* f  = new BContensCTime(CTsr(cser)->FirstCTime());
    1094     BUserCTime* l  = new BContensCTime(CTsr(cser)->LastCTime());
    1095     BList*       arg = LstStack(NIL,cser,f,l,d,NIL);
    1096     BDatStatCenterMoment mom(arg);
    1097     return(mom.Contens());
    1098 }
    1099 
    1100 BDat CStatQuantile(BSyntaxObject* cser, BDat q)
    1101 {
    1102     BUserDat*  d   = new BContensDat(q);
    1103     BUserCTime* f  = new BContensCTime(CTsr(cser)->FirstCTime());
    1104     BUserCTime* l  = new BContensCTime(CTsr(cser)->LastCTime());
    1105     BList*       arg = LstStack(NIL,cser,f,l,d,NIL);
    1106     BDatStatQuantile mom(arg);
    1107     return(mom.Contens());
    1108 }
    1109 #endif // __USE_TC__
    1110 
    1111 //--------------------------------------------------------------------
    1112 DeclareContensClass(BDat, BDatTemporary, BDatBoxPierceLjung);
    1113 DefExtOpr(1, BDatBoxPierceLjung, "BoxPierceLjung", 4, 4,
    1114           "Serie Real Real Real",
    1115           "(Serie ser, Real m, Real p, Real q)",
    1116           I2("Returns the Box-Pierce-Ljung statistic of a serie with m "
    1117              "autocorrelations, p AR-parameters and q MA-parameters",
    1118              "Devuelve el estadístico de Box-Pierce-Ljung de una serie con m "
    1119              "autocorrelaciones, p parámetros AR y q parámetros MA"),
    1120           BOperClassify::Sthocastic_);
    1121 void BDatBoxPierceLjung::CalcContens()
    1122 //--------------------------------------------------------------------
    1123 {
    1124     BSerieTable table;
    1125     table.AddSerie(Tsr(Arg(1)));
    1126     table.Fill();
    1127     BInt m = (BInt)Real(Arg(2));
    1128     BInt p = (BInt)Real(Arg(3));
    1129     BInt q = (BInt)Real(Arg(4));
    1130     contens_ = BoxPierceLjung(table.Data().Data(), m, p, q);
    1131 }
    1132 
    1133 #ifdef __USE_TC__
    1134 //--------------------------------------------------------------------
    1135 /*
    1136 DeclareContensClass(BDat, BDatTemporary, BDatCBoxPierceLjung);
    1137 DefExtOpr(1, BDatCBoxPierceLjung, "CBoxPierceLjung", 4, 4,
    1138           "CSeries Real Real Real",
    1139           "(CSeries cser, Real m, Real p, Real q)",
    1140           I2("Returns the Box-Pierce-Ljung statistic of a series with m "
    1141              "autocorrelations, p AR-parameters and q MA-parameters",
    1142              "Devuelve el estadístico de Box-Pierce-Ljung de una serie con m "
    1143              "autocorrelaciones, p parámetros AR y q parámetros MA"),
    1144           BOperClassify::Sthocastic_);
    1145 */
    1146 //--------------------------------------------------------------------
    1147 /*
    1148 void BDatCBoxPierceLjung::CalcContens()
    1149 {
    1150     BSet s; s.RobElement(NCons(Arg(1)));
    1151     int m = (BInt)Real(Arg(2));
    1152     int p = (BInt)Real(Arg(3));
    1153     int q = (BInt)Real(Arg(4));
    1154     BCSeriesTable table(s);
    1155     contens_ = BoxPierceLjung(table.Data().Data(), m, p, q);
    1156 }
    1157 */
    1158 #endif // __USE_TC__
    1159 
    1160 
     565
     566//--------------------------------------------------------------------
     567DeclareContensClass(BDat, BDatTemporary, BDatBoxPierceLjungACF);
     568DefExtOpr(1, BDatBoxPierceLjungACF, "BoxPierceLjungACF", 3, 3,
     569    "Matrix Real Real",
     570    "(Matrix acf, Real m, Real s)",
     571    I2("Returns the Box-Pierce-Ljung statistic for first ŽmŽ  "
     572       "autocorrelations in vector ŽacfŽ from a time series of length ŽsŽ",
     573       "Devuelve el estadístico de Box-Pierce-Ljung para las ŽsŽ primeras "
     574       "autocorrelaciones del vector ŽacfŽ de una serie temporal de "
     575       "longitud ŽsŽ."),
     576    BOperClassify::Sthocastic_);
     577void BDatBoxPierceLjungACF::CalcContens()
     578//--------------------------------------------------------------------
     579{
     580  BMatrix<BDat>& ACF = Mat(Arg(1));
     581  BInt m = (BInt)Real(Arg(2));
     582  BInt s = (BInt)Real(Arg(3));
     583  contens_ = BoxPierceLjungACF(ACF.Data(), m, s);
     584}
Note: See TracChangeset for help on using the changeset viewer.