Index: tol/bmath/bstat/stat.cpp =================================================================== --- tol/bmath/bstat/stat.cpp (revision b6c14f401d0f9aa1758a710b5e2501e7ec0c7cfb) +++ tol/bmath/bstat/stat.cpp (revision 09bb52bd1a241e1c092813ef19a8c265dbb4a2da) @@ -86,4 +86,23 @@ return((*stat)(x)); } +//-------------------------------------------------------------------- +BDat Known(const BArray& vec) + +/*! Returns the Sum statistic of a vector of real numbers + */ +//-------------------------------------------------------------------- +{ + if(!vec.Size()) { return(0); } + BDat result = 0; + for(BInt k = 0; k& vec) Index: tol/bmath/bstat/tol_bstat.h =================================================================== --- tol/bmath/bstat/tol_bstat.h (revision b6c14f401d0f9aa1758a710b5e2501e7ec0c7cfb) +++ tol/bmath/bstat/tol_bstat.h (revision 09bb52bd1a241e1c092813ef19a8c265dbb4a2da) @@ -33,4 +33,5 @@ const BArray& vec); +TOL_API BDat Known (const BArray& vec); TOL_API BDat Sum (const BArray& vec); TOL_API BDat Product (const BArray& vec); Index: tol/btol/real_type/datgrast.cpp =================================================================== --- tol/btol/real_type/datgrast.cpp (revision b6c14f401d0f9aa1758a710b5e2501e7ec0c7cfb) +++ tol/btol/real_type/datgrast.cpp (revision 09bb52bd1a241e1c092813ef19a8c265dbb4a2da) @@ -153,11 +153,11 @@ //-------------------------------------------------------------------- - DeclareContensClass(BDat, BDatTemporary, BDatAsimetry); - DefIntOpr(1, BDatAsimetry, "Asymmetry", 1, 0, + DeclareContensClass(BDat, BDatTemporary, BDatAsymmetry); + DefIntOpr(1, BDatAsymmetry, "Asymmetry", 1, 0, "(Real x1 [, Real x2, ...])", I2("Returns the asymmetry ceficient of all arguments.", "Devuelve el coeficiente de asimetría de todos sus argumentos."), BOperClassify::Statistic_); - void BDatAsimetry::CalcContens() + void BDatAsymmetry::CalcContens() //-------------------------------------------------------------------- { @@ -320,9 +320,57 @@ //-------------------------------------------------------------------- + DeclareContensClass(BDat, BDatTemporary, BDatMatCount); + DefExtOpr(1, BDatMatCount, "MatCount", 1, 1, "Matrix", + "(Matrix mat)", + I2("Returns the number of cells of a matrix (rows x columns).", + "Devuelve el número de celdas de una matriz (filas x columnas)."), + BOperClassify::Statistic_); + void BDatMatCount::CalcContens() +//-------------------------------------------------------------------- +{ + BMat& x = Mat(Arg(1)); + contens_ = x.Rows() * x.Columns(); +} + +//-------------------------------------------------------------------- + DeclareContensClass(BDat, BDatTemporary, BDatMatKnown); + DefExtOpr(1, BDatMatKnown, "MatKnown", 1, 1, "Matrix", + "(Matrix mat)", + I2("Returns the number of cells of a matrix (rows x columns).", + "Devuelve el número de celdas de una matriz (filas x columnas)."), + BOperClassify::Statistic_); + void BDatMatKnown::CalcContens() +//-------------------------------------------------------------------- +{ + BMat& x = Mat(Arg(1)); + contens_ = Known(x.Data()); +} + +//-------------------------------------------------------------------- + DeclareContensClass(BDat, BDatTemporary, BDatSetKnown); + DefExtOpr(1, BDatSetKnown, "SetKnown", 1, 1, "Set", + I2("(Set set)","(Set cto)"), + I2("Returns the global sum of all elements of a set of numbers.", + "Devuelve el número de elementos no omitidos de un conjunto de números."), + BOperClassify::Statistic_); + void BDatSetKnown::CalcContens() +//-------------------------------------------------------------------- +{ + BSet& set = Set(Arg(1)); + if(!CheckRealElement("SetSum",set)) { return; } + BArray vec(set.Card()); + for(BInt n=0; n& vec = mat.Data(); + contens_ = Moment(vec,m); +} + +//-------------------------------------------------------------------- + DeclareContensClass(BDat, BDatTemporary, BDatMatCenterMoment); + DefExtOpr(1, BDatMatCenterMoment, "MatCenterMoment", 2, 2, "Matrix Real", + "(Matrix mat, Real n)", + I2("Returns the n-th centered moment of all cells of a matrix.", + "Devuelve el momento centrado de orden n de todas las celdas de una " + "matriz."), + BOperClassify::Statistic_); + void BDatMatCenterMoment::CalcContens() +//-------------------------------------------------------------------- +{ + BMat& mat = Mat(Arg(1)); + BInt m = (BInt)Real(Arg(2)); + const BArray& vec = mat.Data(); + contens_ = CenterMoment(vec,m); +} + +/* +//-------------------------------------------------------------------- + DeclareContensClass(BDat, BDatTemporary, BDatSetMoment); + DefExtOpr(1, BDatSetMoment, "MatMoment", 2, 2, "Set Real", + I2("(Set set, Real n)","(Set cto, Real n)"), + I2("Returns the n-th moment of all elements of a set of numbers.", + "Devuelve el momento de orden n de todos los elementos de un " + "conjunto."), + BOperClassify::Statistic_); + void BDatSetMoment::CalcContens() +//-------------------------------------------------------------------- +{ + BSet& set = Set (Arg(1)); + if(!CheckRealElement("SetMoment",set)) { return; } + BInt m = (BInt)Real(Arg(2)); + BArray vec(set.Card()); + for(BInt n=0; n vec(set.Card()); + for(BInt n=0; nTsrR(ser_).LastDate()) + { + contens_ = 0; + } + else + { + contens_ = Known(vec_); //1 + TsrR(ser_).Dating()->Difference(ini_, fin_); + } + } +} + +//-------------------------------------------------------------------- DefExtOpr(1, BDatStatMax, "MaxS", 1, 3, "Serie Date Date", I2("(Serie ser [, Date from, Date until])", @@ -233,4 +262,26 @@ //-------------------------------------------------------------------- + DefExtOpr(1, BDatStatProd, "ProdS", 1, 3, "Serie Date Date", + I2("(Serie ser [, Date from, Date until])", + "(Serie ser [, Date desde, Date hasta])"), + I2("Returns the product of a serie between two dates. " + "If they do not appear, it is assumed the calculation with the " + "first and last dates of the series. Finally, if the series lacks " + "dates, is calculated with the dates by defect.", + "Devuelve el producto de una serie entre dos fechas. " + "Si no aparecen, se asume el cálculo con las fechas primera " + "y última de la serie. Por último, si la serie carece de fechas, " + "se calcula con las fechas por defecto."), + BOperClassify::Statistic_); + void BDatStatProd::CalcContens() +//-------------------------------------------------------------------- +{ + if(ser_ && TsrR(ser_).Dating()) + { + contens_ = Product(vec_); + } +} + +//-------------------------------------------------------------------- DefExtOpr(1, BDatStatAverage, "AvrS", 1, 3, "Serie Date Date", I2("(Serie ser [, Date from, Date until])", @@ -253,4 +304,51 @@ } } + + +//-------------------------------------------------------------------- + DefExtOpr(1, BDatStatGeometricAverage, "GeometricAvrS", 1, 3, "Serie Date Date", + I2("(Serie ser [, Date from, Date until])", + "(Serie ser [, Date desde, Date hasta])"), + I2("Returns the geometric average of a serie between two dates. " + "If they do not appear, it is assumed the calculation with the " + "first and last dates of the series. Finally, if the series lacks " + "dates, is calculated with the dates by defect.", + "Devuelve la media geométrica de una serie entre dos fechas. " + "Si no aparecen, se asume el cálculo con las fechas primera " + "y última de la serie. Por último, si la serie carece de fechas, " + "se calcula con las fechas por defecto."), + BOperClassify::Statistic_); + void BDatStatGeometricAverage::CalcContens() +//-------------------------------------------------------------------- +{ + if(ser_ && TsrR(ser_).Dating()) + { + contens_ = GeometricAverage(vec_); + } +} + + +//-------------------------------------------------------------------- + DefExtOpr(1, BDatStatHarmonicAverage, "HarmonicAvrS", 1, 3, "Serie Date Date", + I2("(Serie ser [, Date from, Date until])", + "(Serie ser [, Date desde, Date hasta])"), + I2("Returns the harmonic average of a serie between two dates. " + "If they do not appear, it is assumed the calculation with the " + "first and last dates of the series. Finally, if the series lacks " + "dates, is calculated with the dates by defect.", + "Devuelve la media armónica de una serie entre dos fechas. " + "Si no aparecen, se asume el cálculo con las fechas primera " + "y última de la serie. Por último, si la serie carece de fechas, " + "se calcula con las fechas por defecto."), + BOperClassify::Statistic_); + void BDatStatHarmonicAverage::CalcContens() +//-------------------------------------------------------------------- +{ + if(ser_ && TsrR(ser_).Dating()) + { + contens_ = HarmonicAverage(vec_); + } +} + @@ -374,9 +472,9 @@ } - -//-------------------------------------------------------------------- - DefExtOpr(1, BDatStatAsimetry, "AsimetryS", 1, 3, "Serie Date Date", - I2("(Serie ser [, Date from, Date until])", - "(Serie ser [, Date desde, Date hasta])"), +static BText _asymmetry_types = "Serie Date Date"; +static BText _asymmetry_args = + I2("(Serie ser [, Date from, Date until])", + "(Serie ser [, Date desde, Date hasta])"); +static BText _asymmetry_desc = I2("Returns the asymmetry coefficient of a serie between two dates. " "If they do not appear, it is assumed the calculation with the " @@ -386,7 +484,16 @@ "Si no aparecen, se asume el cálculo con las fechas primera " "y última de la serie. Por último, si la serie carece de fechas, " - "se calcula con las fechas por defecto."), - BOperClassify::Statistic_); - void BDatStatAsimetry::CalcContens() + "se calcula con las fechas por defecto."); + +//-------------------------------------------------------------------- + DefExtOpr(1, BDatStatAsymmetry, "AsymmetryS", 1, 3, + _asymmetry_types,_asymmetry_args,_asymmetry_desc, + BOperClassify::Statistic_); + DefExtOpr(2, BDatStatAsymmetry, "AsimetryS", 1, 3, + _asymmetry_types,_asymmetry_args,_asymmetry_desc + "\n"+ + I2("DEPRECATED! Please, use AymmetryS", + "OBSOLETO! Por favor, use AymmetryS"), + BOperClassify::Statistic_); + void BDatStatAsymmetry::CalcContens() //-------------------------------------------------------------------- { @@ -448,5 +555,5 @@ I2("(Serie ser, Date from, Date until, Real p)", "(Serie ser, Date desde, Date hasta, Real p)"), - I2("Returns the quantile of a given probability of a serie between two " + I2("Returns the quantile of a given probability p of a serie between two " "dates. ", "Devuelve el cuantil de probabilidad p de una serie entre dos " @@ -525,6 +632,6 @@ { return(BDatStatVarianze (NCons(ser)).Contens()); } -BDat StatAsimetry(BSyntaxObject* ser) -{ return(BDatStatAsimetry (NCons(ser)).Contens()); } +BDat StatAsymmetry(BSyntaxObject* ser) +{ return(BDatStatAsymmetry (NCons(ser)).Contens()); } BDat StatKurtosis(BSyntaxObject* ser) Index: tol/btol/real_type/tol_bdatgra.h =================================================================== --- tol/btol/real_type/tol_bdatgra.h (revision b6c14f401d0f9aa1758a710b5e2501e7ec0c7cfb) +++ tol/btol/real_type/tol_bdatgra.h (revision 09bb52bd1a241e1c092813ef19a8c265dbb4a2da) @@ -109,4 +109,5 @@ DeclareStatisticClass(BDatStatLast); DeclareStatisticClass(BDatStatCount); +DeclareStatisticClass(BDatStatKnown); DeclareStatisticClass(BDatStatMax); DeclareStatisticClass(BDatStatMin); @@ -114,5 +115,8 @@ DeclareStatisticClass(BDatStatQuantile); DeclareStatisticClass(BDatStatSum); +DeclareStatisticClass(BDatStatProd); DeclareStatisticClass(BDatStatAverage); +DeclareStatisticClass(BDatStatGeometricAverage); +DeclareStatisticClass(BDatStatHarmonicAverage); DeclareStatisticClass(BDatStatVarianze); DeclareStatisticClass(BDatStatStDs); @@ -120,5 +124,5 @@ DeclareStatisticClass(BDatStatSubSampleVarianze); DeclareStatisticClass(BDatStatSubSampleStDs); -DeclareStatisticClass(BDatStatAsimetry); +DeclareStatisticClass(BDatStatAsymmetry); DeclareStatisticClass(BDatStatKurtosis); DeclareStatisticClass(BDatStatMoment); @@ -168,5 +172,5 @@ DeclareCStatisticClass(BDatCStatSubSampleVarianze); DeclareCStatisticClass(BDatCStatSubSampleStDs); -DeclareCStatisticClass(BDatCStatAsimetry); +DeclareCStatisticClass(BDatCStatAsymmetry); DeclareCStatisticClass(BDatCStatKurtosis); DeclareCStatisticClass(BDatCStatMoment); @@ -189,5 +193,5 @@ TOL_API BDat StatStDs (BSyntaxObject* ser); TOL_API BDat StatVarianze (BSyntaxObject* ser); -TOL_API BDat StatAsimetry (BSyntaxObject* ser); +TOL_API BDat StatAsymmetry (BSyntaxObject* ser); TOL_API BDat StatKurtosis (BSyntaxObject* ser); TOL_API BDat StatMedian (BSyntaxObject* ser); @@ -206,5 +210,5 @@ TOL_API BDat CStatStDs (BSyntaxObject* cser); TOL_API BDat CStatVarianze (BSyntaxObject* cser); -TOL_API BDat CStatAsimetry (BSyntaxObject* cser); +TOL_API BDat CStatAsymmetry (BSyntaxObject* cser); TOL_API BDat CStatKurtosis (BSyntaxObject* cser); TOL_API BDat CStatMedian (BSyntaxObject* cser); Index: tol/btol/vmatrix_type/vmatgra.cpp =================================================================== --- tol/btol/vmatrix_type/vmatgra.cpp (revision b6c14f401d0f9aa1758a710b5e2501e7ec0c7cfb) +++ tol/btol/vmatrix_type/vmatgra.cpp (revision 09bb52bd1a241e1c092813ef19a8c265dbb4a2da) @@ -39,4 +39,5 @@ #include #include +#include #include @@ -2344,4 +2345,34 @@ //-------------------------------------------------------------------- + DeclareContensClass(BDat, BDatTemporary, BDatVMatCount); + DefExtOpr(1, BDatVMatCount, "VMatCount", 1, 1, "VMatrix", + "(VMatrix mat)", + I2("Returns the number of cells of a matrix (rows x columns).", + "Devuelve el número de celdas de una matriz (filas x columnas)."), + BOperClassify::Statistic_); + void BDatVMatCount::CalcContens() +//-------------------------------------------------------------------- +{ + BVMat& x = VMat(Arg(1)); + contens_ = x.Rows() * x.Columns(); +} + +//-------------------------------------------------------------------- + DeclareContensClass(BDat, BDatTemporary, BDatVMatKnown); + DefExtOpr(1, BDatVMatKnown, "VMatKnown", 1, 1, "VMatrix", + "(VMatrix mat)", + I2("Returns the number of cells of a matrix (rows x columns).", + "Devuelve el número de celdas de una matriz (filas x columnas)."), + BOperClassify::Statistic_); + void BDatVMatKnown::CalcContens() +//-------------------------------------------------------------------- +{ + BVMat& x = VMat(Arg(1)); + BMat y; + x.GetDMatT(*((DMat*)&y)); + contens_ = Known(y.Data()); +} + +//-------------------------------------------------------------------- DeclareContensClass(BDat, BDatTemporary, BDatVMatSum); DefExtOpr(1, BDatVMatSum, "VMatSum", 1, 1, "VMatrix", @@ -2357,4 +2388,20 @@ //-------------------------------------------------------------------- + DeclareContensClass(BDat, BDatTemporary, BDatVMatProduct); + DefExtOpr(1, BDatVMatProduct, "VMatProduct", 1, 1, "VMatrix", + "(VMatrix mat)", + I2("Returns the product of all elements of a matrix.", + "Devuelve el producto de todos los elementos de una matriz."), + BOperClassify::Statistic_); + void BDatVMatProduct::CalcContens() +//-------------------------------------------------------------------- +{ + BVMat& x = VMat(Arg(1)); + BMat y; + x.GetDMatT(*((DMat*)&y)); + contens_ = Product(y.Data()); +} + +//-------------------------------------------------------------------- DeclareContensClass(BDat, BDatTemporary, BDatVMatAvr); DefExtOpr(1, BDatVMatAvr, "VMatAvr", 1, 1, "VMatrix", @@ -2370,4 +2417,37 @@ //-------------------------------------------------------------------- + DeclareContensClass(BDat, BDatTemporary, BDatVMatGeometricAvr); + DefExtOpr(1, BDatVMatGeometricAvr, "VMatGeometricAvr", 1, 1, "VMatrix", + "(VMatrix mat)", + I2("Returns the geometric average of all elements of a matrix.", + "Devuelve la media geométrica de todos los elementos de una matriz."), + BOperClassify::Statistic_); + void BDatVMatGeometricAvr::CalcContens() +//-------------------------------------------------------------------- +{ + BVMat& x = VMat(Arg(1)); + BMat y; + x.GetDMatT(*((DMat*)&y)); + contens_ = GeometricAverage(y.Data()); +} + +//-------------------------------------------------------------------- + DeclareContensClass(BDat, BDatTemporary, BDatVMatHarmonicAvr); + DefExtOpr(1, BDatVMatHarmonicAvr, "VMatHarmonicAvr", 1, 1, "VMatrix", + "(VMatrix mat)", + I2("Returns the harmonic average of all elements of a matrix.", + "Devuelve la media armónica de todos los elementos de una matriz."), + BOperClassify::Statistic_); + void BDatVMatHarmonicAvr::CalcContens() +//-------------------------------------------------------------------- +{ + BVMat& x = VMat(Arg(1)); + BMat y; + x.GetDMatT(*((DMat*)&y)); + contens_ = GeometricAverage(y.Data()); +} + + +//-------------------------------------------------------------------- DeclareContensClass(BDat, BDatTemporary, BDatVMatVar); DefExtOpr(1, BDatVMatVar, "VMatVar", 1, 1, "VMatrix", @@ -2420,4 +2500,38 @@ contens_ = VMat(Arg(1)).Kurtosis(); } + +//-------------------------------------------------------------------- + DeclareContensClass(BDat, BDatTemporary, BDatVMatMedian); + DefExtOpr(1, BDatVMatMedian, "VMatMedian", 1, 1, "VMatrix", + "(VMatrix mat)", + I2("Returns the median of all elements of a matrix.", + "Devuelve la mediana de todos los elementos de una matriz."), + BOperClassify::Statistic_); + void BDatVMatMedian::CalcContens() +//-------------------------------------------------------------------- +{ + BVMat& x = VMat(Arg(1)); + BMat y; + x.GetDMatT(*((DMat*)&y)); + contens_ = Median(y.Data()); +} + +//-------------------------------------------------------------------- + DeclareContensClass(BDat, BDatTemporary, BDatVMatQunatile); + DefExtOpr(1, BDatVMatQunatile, "VMatQuantile", 2, 2, "VMatrix Real", + "(VMatrix mat, Real p)", + I2("Returns the the quantile of a given probability p of all elements of a matrix.", + "Devuelve el cuantil de probabilidad p de todos los elementos de una matriz."), + BOperClassify::Statistic_); + void BDatVMatQunatile::CalcContens() +//-------------------------------------------------------------------- +{ + BVMat& x = VMat(Arg(1)); + BDat p = Dat(Arg(2)); + BMat y; + x.GetDMatT(*((DMat*)&y)); + contens_ = Quantile(y.Data(),p); +} + //-------------------------------------------------------------------- Index: tol/lang/language.cpp =================================================================== --- tol/lang/language.cpp (revision b6c14f401d0f9aa1758a710b5e2501e7ec0c7cfb) +++ tol/lang/language.cpp (revision 09bb52bd1a241e1c092813ef19a8c265dbb4a2da) @@ -768,13 +768,13 @@ if(header=="_DEFAULT_HEADER_") { - table[i++][0] = I2("Statistic ", "Estadï¿œstico"); + table[i++][0] = I2("Statistic ", "Estadístico"); table[i++][0] = I2("Count ", "Longitud "); - table[i++][0] = I2("Maximum ", "Mï¿œximo "); - table[i++][0] = I2("Minimum ", "Mï¿œnimo "); + table[i++][0] = I2("Maximum ", "Máximo "); + table[i++][0] = I2("Minimum ", "Mínimo "); table[i++][0] = I2("Sum ", "Suma "); table[i++][0] = I2("Average ", "Media "); table[i++][0] = I2("Std. Desv. ", "Desv. Tip. "); table[i++][0] = I2("Varianze ", "Varianza "); - table[i++][0] = I2("Asymmetry ", "Asimetrï¿œa "); + table[i++][0] = I2("Asymmetry ", "Asimetría "); table[i++][0] = I2("Kurtosis ", "Curtosis "); table[i++][0] = I2("Median ", "Mediana "); @@ -798,14 +798,14 @@ i=0; table[i++][j] = ser->Identify(); - table[i++][j] = StatCount (ser).Name(); - table[i++][j] = StatMax (ser).Name(); - table[i++][j] = StatMin (ser).Name(); - table[i++][j] = StatSum (ser).Name(); - table[i++][j] = StatAverage (ser).Name(); - table[i++][j] = StatStDs (ser).Name(); - table[i++][j] = StatVarianze(ser).Name(); - table[i++][j] = StatAsimetry(ser).Name(); - table[i++][j] = StatKurtosis(ser).Name(); - table[i++][j] = StatMedian (ser).Name(); + table[i++][j] = StatCount (ser).Name(); + table[i++][j] = StatMax (ser).Name(); + table[i++][j] = StatMin (ser).Name(); + table[i++][j] = StatSum (ser).Name(); + table[i++][j] = StatAverage (ser).Name(); + table[i++][j] = StatStDs (ser).Name(); + table[i++][j] = StatVarianze (ser).Name(); + table[i++][j] = StatAsymmetry(ser).Name(); + table[i++][j] = StatKurtosis (ser).Name(); + table[i++][j] = StatMedian (ser).Name(); } lst = Cdr(lst);