PLearn 0.1
StatsIterator.cc
Go to the documentation of this file.
00001 // -*- C++ -*-
00002 
00003 // PLearn (A C++ Machine Learning Library)
00004 // Copyright (C) 1998 Pascal Vincent
00005 // Copyright (C) 1999-2002 Pascal Vincent, Yoshua Bengio and University of Montreal
00006 //
00007 
00008 // Redistribution and use in source and binary forms, with or without
00009 // modification, are permitted provided that the following conditions are met:
00010 // 
00011 //  1. Redistributions of source code must retain the above copyright
00012 //     notice, this list of conditions and the following disclaimer.
00013 // 
00014 //  2. Redistributions in binary form must reproduce the above copyright
00015 //     notice, this list of conditions and the following disclaimer in the
00016 //     documentation and/or other materials provided with the distribution.
00017 // 
00018 //  3. The name of the authors may not be used to endorse or promote
00019 //     products derived from this software without specific prior written
00020 //     permission.
00021 // 
00022 // THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
00023 // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
00024 // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
00025 // NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
00026 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
00027 // TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
00028 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
00029 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
00030 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
00031 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00032 // 
00033 // This file is part of the PLearn library. For more information on the PLearn
00034 // library, go to the PLearn Web site at www.plearn.org
00035  
00036 
00037 /* *******************************************************      
00038  * $Id: StatsIterator.cc 3994 2005-08-25 13:35:03Z chapados $
00039  * This file is part of the PLearn library.
00040  ******************************************************* */
00041 
00042 #include "StatsIterator.h"
00043 #include "TMat_maths.h"
00044 
00045 namespace PLearn {
00046 using namespace std;
00047 
00048 // *******************
00049 // ** StatsIterator ** 
00050 // *******************
00051 
00052 PLEARN_IMPLEMENT_ABSTRACT_OBJECT(StatsIterator, "ONE LINE DESCR", "NO HELP");
00053 void StatsIterator::makeDeepCopyFromShallowCopy(CopiesMap& copies)
00054 {
00055     inherited::makeDeepCopyFromShallowCopy(copies);
00056     deepCopyField(result, copies);
00057 }
00058 
00059 bool StatsIterator::requiresMultiplePasses() { return false; }
00060 
00061 Vec StatsIterator::getResult() { return result; }
00062 
00063 void StatsIterator::declareOptions(OptionList& ol)
00064 {
00065     declareOption(ol, "result", &StatsIterator::result, OptionBase::learntoption, 
00066                   "    result\n");
00067 
00068     inherited::declareOptions(ol);
00069 }
00070 
00071 void StatsIterator::oldwrite(ostream& out) const
00072 {
00073     writeHeader(out,"StatsIterator");
00074     //inherited::write(out);
00075     writeField(out,"result",result);
00076     writeFooter(out,"StatsIterator");
00077 }
00078 
00079 /* TODO Remove (deprecated)
00080    void StatsIterator::oldread(istream& in)
00081    {
00082    readHeader(in,"StatsIterator");
00083    //inherited::read(int);
00084    readField(in,"result",result);
00085    readFooter(in,"StatsIterator");
00086    }
00087 */
00088 
00089 // ***********************
00090 // ** MeanStatsIterator ** 
00091 // ***********************
00092 
00093 PLEARN_IMPLEMENT_OBJECT(MeanStatsIterator, "ONE LINE DESCR", "NO HELP");
00094 
00095 void MeanStatsIterator::init(int inputsize)
00096 { 
00097     // We do not use resize on purpose, so 
00098     // that the previous result Vec does not get overwritten
00099     result = Vec(inputsize);
00100     nsamples.resize(inputsize);
00101     nsamples.clear();
00102 } 
00103 
00104 void MeanStatsIterator::update(const Vec& input)
00105 { 
00106     addIfNonMissing(input,nsamples,result);
00107 }
00108 
00109 bool MeanStatsIterator::finish()
00110 {
00111     for (int i=0;i<result.length();i++)
00112         result[i] /= nsamples[i];
00113     return true;
00114 }
00115 
00116 void MeanStatsIterator::declareOptions(OptionList& ol)
00117 {
00118     declareOption(ol, "nsamples", &MeanStatsIterator::nsamples, OptionBase::learntoption, 
00119                   "    nsamples\n");
00120 
00121     inherited::declareOptions(ol);
00122 }
00123 
00124 
00125 void MeanStatsIterator::oldwrite(ostream& out) const
00126 {
00127     writeHeader(out,"MeanStatsIterator");
00128     inherited::write(out);
00129     writeField(out,"nsamples",nsamples);
00130     writeFooter(out,"MeanStatsIterator");
00131 }
00132 
00133 /* TODO Remove (deprecated)
00134    void MeanStatsIterator::oldread(istream& in)
00135    {
00136    readHeader(in,"MeanStatsIterator");
00137    inherited::oldread(in);
00138    readField(in,"nsamples",nsamples);
00139    readFooter(in,"MeanStatsIterator");
00140    }
00141 */
00142 
00143 // ***********************
00144 // ** ExpMeanStatsIterator ** 
00145 // ***********************
00146 
00147 PLEARN_IMPLEMENT_OBJECT(ExpMeanStatsIterator, "ONE LINE DESCR", "NO HELP");
00148 
00149 void ExpMeanStatsIterator::init(int inputsize)
00150 { 
00151     // We do not use resize on purpose, so 
00152     // that the previous result Vec does not get overwritten
00153     result = Vec(inputsize);
00154     nsamples.resize(inputsize);
00155     nsamples.clear();
00156 } 
00157 
00158 void ExpMeanStatsIterator::update(const Vec& input)
00159 { 
00160     addIfNonMissing(input,nsamples,result);
00161 }
00162 
00163 bool ExpMeanStatsIterator::finish()
00164 {
00165     for (int i=0;i<result.length();i++)
00166         result[i] = exp(result[i]/nsamples[i]);
00167     return true;
00168 }
00169 
00170 void ExpMeanStatsIterator::declareOptions(OptionList& ol)
00171 {
00172     declareOption(ol, "nsamples", &ExpMeanStatsIterator::nsamples, OptionBase::learntoption, 
00173                   "    nsamples\n");
00174 
00175     inherited::declareOptions(ol);
00176 }
00177 
00178 void ExpMeanStatsIterator::oldwrite(ostream& out) const
00179 {
00180     writeHeader(out,"ExpMeanStatsIterator");
00181     inherited::write(out);
00182     writeField(out,"nsamples",nsamples);
00183     writeFooter(out,"ExpMeanStatsIterator");
00184 }
00185 
00186 /* TODO Remove (deprecated)
00187    void ExpMeanStatsIterator::oldread(istream& in)
00188    {
00189    readHeader(in,"ExpMeanStatsIterator");
00190    inherited::oldread(in);
00191    readField(in,"nsamples",nsamples);
00192    readFooter(in,"ExpMeanStatsIterator");
00193    }
00194 */
00195 
00196 // *************************
00197 // ** StddevStatsIterator ** 
00198 // *************************
00199 
00200 PLEARN_IMPLEMENT_OBJECT(StddevStatsIterator, "ONE LINE DESCR", "NO HELP");
00201 
00202 void StddevStatsIterator::makeDeepCopyFromShallowCopy(CopiesMap& copies)
00203 {
00204     inherited::makeDeepCopyFromShallowCopy(copies);
00205     deepCopyField(mean, copies);
00206     deepCopyField(meansquared, copies);
00207 }
00208 
00209 void StddevStatsIterator::init(int inputsize)
00210 { 
00211     // We do not use resize on purpose, so 
00212     // that the previous result Vec does not get overwritten
00213     meansquared = Vec(inputsize);
00214     mean = Vec(inputsize);
00215     nsamples.resize(inputsize);
00216     nsamples.clear();
00217 } 
00218 
00219 void StddevStatsIterator::update(const Vec& input)
00220 { 
00221     addXandX2IfNonMissing(input,nsamples,mean,meansquared);
00222 }
00223 
00224 bool StddevStatsIterator::finish()
00225 {
00226     Vec square_mean(mean.length());
00227     for (int i=0;i<mean.length();i++)
00228     {
00229         //mean[i] /= nsamples[i];
00230         real n = nsamples[i];
00231         square_mean[i] = mean[i]*mean[i]/(n*(n-1.0));
00232         meansquared[i] /= n-1.0;
00233     }
00234     //squareSubtract(meansquared, mean);
00235     meansquared -= square_mean;
00236     result = sqrt(meansquared);
00237     return true;
00238 }
00239 
00240 void StddevStatsIterator::declareOptions(OptionList& ol)
00241 {
00242     declareOption(ol, "mean", &StddevStatsIterator::mean, OptionBase::learntoption, 
00243                   "    mean\n");
00244 
00245     declareOption(ol, "meansquared", &StddevStatsIterator::meansquared, OptionBase::learntoption, 
00246                   "    meansquared\n");
00247 
00248     declareOption(ol, "nsamples", &StddevStatsIterator::nsamples, OptionBase::learntoption, 
00249                   "    nsamples\n");
00250 
00251     inherited::declareOptions(ol);
00252 }
00253 
00254 void StddevStatsIterator::oldwrite(ostream& out) const
00255 {
00256     writeHeader(out,"StddevStatsIterator");
00257     inherited::write(out);
00258     writeField(out,"mean",mean);
00259     writeField(out,"meansquared",meansquared);
00260     writeField(out,"nsamples",nsamples);
00261     writeFooter(out,"StddevStatsIterator");
00262 }
00263 
00264 /* TODO Remove (deprecated)
00265    void StddevStatsIterator::oldread(istream& in)
00266    {
00267    readHeader(in,"StddevStatsIterator");
00268    inherited::oldread(in);
00269    readField(in,"mean",mean);
00270    readField(in,"meansquared",meansquared);
00271    readField(in,"nsamples",nsamples);
00272    readFooter(in,"StddevStatsIterator");
00273    }
00274 */
00275 
00276 // *************************
00277 // ** StderrStatsIterator ** 
00278 // *************************
00279 
00280 PLEARN_IMPLEMENT_OBJECT(StderrStatsIterator, "ONE LINE DESCR", "NO HELP");
00281 
00282 void StderrStatsIterator::makeDeepCopyFromShallowCopy(CopiesMap& copies)
00283 {
00284     inherited::makeDeepCopyFromShallowCopy(copies);
00285     deepCopyField(mean, copies);
00286     deepCopyField(meansquared, copies);
00287 }
00288 
00289 void StderrStatsIterator::init(int inputsize)
00290 { 
00291     // We do not use resize on purpose, so 
00292     // that the previous result Vec does not get overwritten
00293     meansquared = Vec(inputsize);
00294     mean = Vec(inputsize);
00295     nsamples.resize(inputsize);
00296     nsamples.clear();
00297 } 
00298 
00299 void StderrStatsIterator::update(const Vec& input)
00300 { 
00301     addXandX2IfNonMissing(input,nsamples,mean,meansquared);
00302 }
00303 
00304 bool StderrStatsIterator::finish()
00305 {
00306     for (int i=0;i<mean.length();i++)
00307     {
00308         mean[i] /= nsamples[i];
00309         meansquared[i] /= nsamples[i]-1;
00310     }
00311     squareSubtract(meansquared, mean);
00312     for (int i = 0; i < mean.length(); i++) {
00313         result[i] = sqrt(meansquared[i] / real(nsamples[i]));
00314     }
00315     return true;
00316 }
00317 
00318 void StderrStatsIterator::declareOptions(OptionList& ol)
00319 {
00320     declareOption(ol, "mean", &StderrStatsIterator::mean, OptionBase::learntoption, 
00321                   "    mean\n");
00322 
00323     declareOption(ol, "meansquared", &StderrStatsIterator::meansquared, OptionBase::learntoption, 
00324                   "    meansquared\n");
00325 
00326     declareOption(ol, "nsamples", &StderrStatsIterator::nsamples, OptionBase::learntoption, 
00327                   "    nsamples\n");
00328 
00329     inherited::declareOptions(ol);
00330 }
00331 
00332 void StderrStatsIterator::oldwrite(ostream& out) const
00333 {
00334     writeHeader(out,"StderrStatsIterator");
00335     inherited::write(out);
00336     writeField(out,"mean",mean);
00337     writeField(out,"meansquared",meansquared);
00338     writeField(out,"nsamples",nsamples);
00339     writeFooter(out,"StderrStatsIterator");
00340 }
00341 
00342 /* TODO Remove (deprecated)
00343    void StderrStatsIterator::oldread(istream& in)
00344    {
00345    readHeader(in,"StderrStatsIterator");
00346    inherited::oldread(in);
00347    readField(in,"mean",mean);
00348    readField(in,"meansquared",meansquared);
00349    readField(in,"nsamples",nsamples);
00350    readFooter(in,"StderrStatsIterator");
00351    }
00352 */
00353 
00354 // *************************
00355 // ** SharpeRatioStatsIterator ** 
00356 // *************************
00357 
00358 PLEARN_IMPLEMENT_OBJECT(SharpeRatioStatsIterator, "ONE LINE DESCR", "NO HELP");
00359 
00360 void SharpeRatioStatsIterator::makeDeepCopyFromShallowCopy(CopiesMap& copies)
00361 {
00362     inherited::makeDeepCopyFromShallowCopy(copies);
00363     deepCopyField(mean, copies);
00364     deepCopyField(meansquared, copies);
00365 }
00366 
00367 void SharpeRatioStatsIterator::init(int inputsize)
00368 { 
00369     // We do not use resize on purpose, so 
00370     // that the previous result Vec does not get overwritten
00371     meansquared = Vec(inputsize);
00372     mean = Vec(inputsize);
00373     nnonzero = Vec(inputsize);
00374 } 
00375 
00376 void SharpeRatioStatsIterator::update(const Vec& input)
00377 { 
00378     int n=input.length();
00379     for (int i=0;i<n;i++)
00380     {
00381         real in=input[i];
00382         if (in!=0) nnonzero[i]++;
00383         mean[i] += in;
00384         meansquared[i] += in*in;
00385     }
00386 }
00387 
00388 bool SharpeRatioStatsIterator::finish()
00389 {
00390     mean /= nnonzero;
00391     meansquared /= nnonzero;
00392     squareSubtract(meansquared, mean);
00393     result = mean/sqrt(meansquared);
00394     return true;
00395 }
00396 
00397 void SharpeRatioStatsIterator::declareOptions(OptionList& ol)
00398 {
00399     declareOption(ol, "mean", &SharpeRatioStatsIterator::mean, OptionBase::learntoption, 
00400                   "    mean\n");
00401 
00402     declareOption(ol, "meansquared", &SharpeRatioStatsIterator::meansquared, OptionBase::learntoption, 
00403                   "    meansquared\n");
00404 
00405     declareOption(ol, "nnonzero", &SharpeRatioStatsIterator::nnonzero, OptionBase::learntoption, 
00406                   "    nnonzero\n");
00407 
00408     inherited::declareOptions(ol);
00409 }
00410 
00411 void SharpeRatioStatsIterator::oldwrite(ostream& out) const
00412 {
00413     writeHeader(out,"SharpeRatioStatsIterator");
00414     inherited::write(out);
00415     writeField(out,"mean",mean);
00416     writeField(out,"meansquared",meansquared);
00417     writeField(out,"nnonzero",nnonzero);
00418     writeFooter(out,"SharpeRatioStatsIterator");
00419 }
00420 
00421 /* TODO Remove (deprecated)
00422    void SharpeRatioStatsIterator::oldread(istream& in)
00423    {
00424    readHeader(in,"SharpeRatioStatsIterator");
00425    inherited::oldread(in);
00426    readField(in,"mean",mean);
00427    readField(in,"meansquared",meansquared);
00428    readField(in,"nnonzero",nnonzero);
00429    readFooter(in,"SharpeRatioStatsIterator");
00430    }
00431 */
00432 
00433 // ***********************
00434 // ** MinStatsIterator ** 
00435 // ***********************
00436 
00437 PLEARN_IMPLEMENT_OBJECT(MinStatsIterator, "ONE LINE DESCR", "NO HELP");
00438 
00439 void MinStatsIterator::init(int inputsize)
00440 { 
00441     result = Vec(inputsize,FLT_MAX);
00442 } 
00443 
00444 void MinStatsIterator::update(const Vec& input)
00445 { 
00446     real* inputdata = input.data();
00447     real* resultdata = result.data();
00448     for(int i=0; i<input.length(); i++)
00449         if(inputdata[i]<resultdata[i])
00450             resultdata[i] = inputdata[i];
00451 }
00452 
00453 bool MinStatsIterator::finish()
00454 { return true; }
00455 
00456 void MinStatsIterator::declareOptions(OptionList& ol)
00457 {
00458     inherited::declareOptions(ol);
00459 }
00460 
00461 void MinStatsIterator::oldwrite(ostream& out) const
00462 {
00463     writeHeader(out,"MinStatsIterator");
00464     inherited::write(out);
00465     writeFooter(out,"MinStatsIterator");
00466 }
00467 
00468 /* TODO Remove (deprecated)
00469    void MinStatsIterator::oldread(istream& in)
00470    {
00471    readHeader(in,"MinStatsIterator");
00472    inherited::oldread(in);
00473    readFooter(in,"MinStatsIterator");
00474    }
00475 */
00476 
00477 // ***********************
00478 // ** MaxStatsIterator ** 
00479 // ***********************
00480 
00481 PLEARN_IMPLEMENT_OBJECT(MaxStatsIterator, "ONE LINE DESCR", "NO HELP");
00482 
00483 void MaxStatsIterator::init(int inputsize)
00484 { 
00485     // We do not use resize on purpose, so 
00486     // that the previous result Vec does not get overwritten
00487     result = Vec(inputsize,-FLT_MAX);
00488 } 
00489 
00490 void MaxStatsIterator::update(const Vec& input)
00491 { 
00492     real* inputdata = input.data();
00493     real* resultdata = result.data();
00494     for(int i=0; i<input.length(); i++)
00495         if(inputdata[i]>resultdata[i])
00496             resultdata[i] = inputdata[i];
00497 }
00498 
00499 bool MaxStatsIterator::finish()
00500 { return true; }
00501 
00502 void MaxStatsIterator::declareOptions(OptionList& ol)
00503 {
00504     inherited::declareOptions(ol);
00505 }
00506 
00507 void MaxStatsIterator::oldwrite(ostream& out) const
00508 {
00509     writeHeader(out,"MaxStatsIterator");
00510     inherited::write(out);
00511     writeFooter(out,"MaxStatsIterator");
00512 }
00513 
00514 /* TODO Remove (deprecated)
00515    void MaxStatsIterator::oldread(istream& in)
00516    {
00517    readHeader(in,"MaxStatsIterator");
00518    inherited::oldread(in);
00519    readFooter(in,"MaxStatsIterator");
00520    }
00521 */
00522 
00523 
00524 // ***********************
00525 // ** LiftStatsIterator **
00526 // ***********************
00527  
00528 PLEARN_IMPLEMENT_OBJECT(LiftStatsIterator, "ONE LINE DESCR", "NO HELP");
00529 void LiftStatsIterator::makeDeepCopyFromShallowCopy(CopiesMap& copies)
00530 {
00531     StatsIterator::makeDeepCopyFromShallowCopy(copies);
00532     deepCopyField(output_and_pos, copies);
00533     deepCopyField(targets, copies);
00534 }
00535  
00536 LiftStatsIterator::LiftStatsIterator(int the_index, real the_fraction)
00537     : nsamples(-1),
00538       lift_index(the_index),
00539       lift_fraction(the_fraction)
00540 {}
00541 
00542 void LiftStatsIterator::init(int inputsize)
00543 {
00544     // We do not use resize on purpose, so
00545     // that the previous result Vec does not get overwritten
00546     result = Vec(2);
00547 
00548     const int initial_length = 1000;
00549     output_and_pos.resize(initial_length, 2);  // 1 output + 1 pos
00550     targets.resize(initial_length);
00551     nsamples = 0;
00552 }
00553  
00554 void LiftStatsIterator::update(const Vec& input)
00555 {
00556     if (nsamples == output_and_pos.length())
00557     {
00558         output_and_pos.resize(10*output_and_pos.length(), 2);
00559         targets.resize(10*output_and_pos.length());
00560     }
00561 
00562     output_and_pos(nsamples, 0) = FABS(input[lift_index]);
00563     output_and_pos(nsamples, 1) = nsamples;
00564     targets[nsamples] = (input[lift_index]>0) ? 1 : 0;
00565     nsamples++;
00566 }
00567  
00568 bool LiftStatsIterator::finish()
00569 {
00570     output_and_pos.resize(nsamples,2);
00571     targets.resize(nsamples);
00572 
00573     const int n_first_samples = int(lift_fraction*nsamples);
00574     const int n_last_samples = nsamples - n_first_samples;
00575     selectAndOrder(output_and_pos, n_last_samples);
00576     /*
00577       Vec first_samples_index =
00578       output_and_pos.subMat(n_last_samples,1,n_first_samples,1).toVecCopy();
00579     */
00580     TVec<int> first_samples_index(n_first_samples);
00581     first_samples_index << output_and_pos.subMat(n_last_samples,1,n_first_samples,1);
00582 
00583     Vec first_samples_targets = targets(first_samples_index);
00584     real first_samples_perf = sum(first_samples_targets)/n_first_samples;
00585     real targets_perf = sum(targets)/nsamples;
00586     real lift = first_samples_perf/targets_perf*100.0;
00587     result[0] = lift;
00588     real nones = sum(targets);
00589     real max_first_samples_perf = MIN(nones,(real)n_first_samples)/n_first_samples;
00590     real max_lift = max_first_samples_perf/targets_perf*100.0;
00591     result[1] = lift/max_lift;
00592 
00593     return true;
00594 }
00595  
00596 void LiftStatsIterator::declareOptions(OptionList& ol)
00597 {
00598     declareOption(ol, "nsamples", &LiftStatsIterator::nsamples, OptionBase::learntoption, 
00599                   "    nsamples\n");
00600 
00601     declareOption(ol, "lift_index", &LiftStatsIterator::lift_index, OptionBase::buildoption, 
00602                   "    lift_index\n");
00603 
00604     declareOption(ol, "lift_fraction", &LiftStatsIterator::lift_fraction, OptionBase::buildoption, 
00605                   "    lift_fraction\n");
00606 
00607     declareOption(ol, "output_and_pos", &LiftStatsIterator::output_and_pos, OptionBase::learntoption, 
00608                   "    output_and_pos\n");
00609 
00610     declareOption(ol, "targets", &LiftStatsIterator::targets, OptionBase::learntoption, 
00611                   "    targets\n");
00612 
00613     inherited::declareOptions(ol);
00614 }
00615 
00616 void LiftStatsIterator::oldwrite(ostream& out) const
00617 {
00618     writeHeader(out,"LiftStatsIterator");
00619     inherited::write(out);
00620     writeField(out,"nsamples",nsamples);
00621     writeField(out,"lift_index",lift_index);
00622     writeField(out,"lift_fraction",lift_fraction);
00623     writeField(out,"output_and_pos",output_and_pos);
00624     writeField(out,"targets",targets);
00625     writeFooter(out,"LiftStatsIterator");
00626 }
00627 
00628 /* TODO Remove (deprecated)
00629    void LiftStatsIterator::oldread(istream& in)
00630    {
00631    readHeader(in,"LiftStatsIterator");
00632    inherited::oldread(in);
00633    readField(in,"nsamples",nsamples);
00634    readField(in,"lift_index",lift_index);
00635    readField(in,"lift_fraction",lift_fraction);
00636    readField(in,"output_and_pos",output_and_pos);
00637    readField(in,"targets",targets);
00638    readFooter(in,"LiftStatsIterator");
00639    }
00640 */
00641 
00642 // ****************************
00643 // ** QuantilesStatsIterator **
00644 // ****************************
00645 
00646 PLEARN_IMPLEMENT_OBJECT(QuantilesStatsIterator, "ONE LINE DESCR", "NO HELP");
00647 
00648 void QuantilesStatsIterator::makeDeepCopyFromShallowCopy(CopiesMap& copies)
00649 {
00650     StatsIterator::makeDeepCopyFromShallowCopy(copies);
00651     deepCopyField(quantiles, copies);
00652     deepCopyField(data, copies);
00653 }
00654  
00655 QuantilesStatsIterator::QuantilesStatsIterator(Vec quantiles_,int n_data)
00656     : nsamples(n_data), quantiles(quantiles_)
00657 { 
00658 }
00659 
00660 void QuantilesStatsIterator::init(int inputsize)
00661 {
00662     data.resize(inputsize);
00663     for (int i=0;i<inputsize;i++)
00664     {
00665         data[i].resize(nsamples);
00666         data[i].resize(0);
00667     }
00668     nsamples=0;
00669     // We do not use resize on purpose, so
00670     // that the previous result Vec does not get overwritten
00671     result = Vec(quantiles.length()*data.length());
00672 }
00673  
00674 void QuantilesStatsIterator::update(const Vec& input)
00675 {
00676     if (nsamples == data[0].length())
00677     {
00678         for (int i=0;i<data.length();i++)
00679         {
00680             data[i].resize(10*(nsamples+1));
00681             data[i].resize(nsamples);
00682         }
00683     }
00684 
00685     for (int i=0;i<input.length();i++)
00686         data[i].push_back(input[i]);
00687     nsamples++;
00688 }
00689  
00690 bool QuantilesStatsIterator::finish()
00691 {
00692     for (int i=0;i<data.length();i++)
00693         sortElements(data[i]);
00694     real dq =real(1.0)/nsamples;
00695     real hdq = dq*real(0.5);
00696     Mat results = result.toMat(data.length(),quantiles.length());
00697     results.fill(MISSING_VALUE);
00698     for (int i=0;i<data.length();i++) // loop over "variables"
00699     {
00700         real q=0;
00701         for (int t=0;t<nsamples;t++,q+=dq)
00702         {
00703             for (int j=0;j<quantiles.length();j++)
00704                 if (quantiles[j]>q-hdq && quantiles[j]<=q+hdq)
00705                     results(i,j) = data[i][t];
00706         }
00707     }
00708     return true;
00709 }
00710  
00711 void QuantilesStatsIterator::declareOptions(OptionList& ol)
00712 {
00713     declareOption(ol, "nsamples", &QuantilesStatsIterator::nsamples, OptionBase::buildoption, 
00714                   "    nsamples\n");
00715 
00716     declareOption(ol, "quantiles", &QuantilesStatsIterator::quantiles, OptionBase::buildoption, 
00717                   "    quantiles\n");
00718 
00719     inherited::declareOptions(ol);
00720 }
00721 
00722 void QuantilesStatsIterator::oldwrite(ostream& out) const
00723 {
00724     writeHeader(out,"QuantilesStatsIterator");
00725     inherited::write(out);
00726     writeField(out,"nsamples",nsamples);
00727     writeField(out,"quantiles",quantiles);
00728     writeFooter(out,"QuantilesStatsIterator");
00729 }
00730 
00731 /* TODO Remove (deprecated)
00732    void QuantilesStatsIterator::oldread(istream& in)
00733    {
00734    readHeader(in,"QuantilesStatsIterator");
00735    inherited::oldread(in);
00736    readField(in,"nsamples",nsamples);
00737    readField(in,"quantiles",quantiles);
00738    readFooter(in,"QuantilesStatsIterator");
00739    }
00740 */
00741 
00742 // ******************
00743 // ** StatsItArray **
00744 // ******************
00745 
00746 StatsItArray::StatsItArray() 
00747     : Array<StatsIt>(0,5)
00748 {}
00749 
00750 StatsItArray::StatsItArray(const StatsIt& statsit)
00751     : Array<StatsIt>(1,5)
00752 { (*this)[0] = statsit; }
00753 
00754 StatsItArray::StatsItArray(const StatsIt& statsit1, const StatsIt& statsit2)
00755     : Array<StatsIt>(2,5)
00756 {
00757     (*this)[0] = statsit1;
00758     (*this)[1] = statsit2;
00759 }
00760 
00761 void StatsItArray::init(int inputsize)
00762 {
00763     for(int k=0; k<size(); k++)
00764         (*this)[k]->init(inputsize);
00765 }
00766 
00767 void StatsItArray::update(const Vec& input)
00768 {
00769     for(int k=0; k<size(); k++)
00770         (*this)[k]->update(input);
00771 }
00772 void StatsItArray::update(const Mat& inputs)
00773 {
00774     for (int i=0;i<inputs.length();i++)
00775     {
00776         Vec input = inputs(i);
00777         update(input);
00778     }
00779 }
00780 
00781 bool StatsItArray::requiresMultiplePasses()
00782 {
00783     for(int k=0; k<size(); k++)
00784         if ( (*this)[k]->requiresMultiplePasses() )
00785             return true;
00786     return false;
00787 }
00788 
00789 // returns an array of those that are not yet finished
00790 StatsItArray StatsItArray::finish()
00791 {
00792     StatsItArray unfinished;
00793     for(int k=0; k<size(); k++)
00794         if ( ! (*this)[k]->finish() )
00795             unfinished.append((*this)[k]);
00796     return unfinished;
00797 }
00798 
00799 Array<Vec> StatsItArray::getResults()
00800 {
00801     Array<Vec> results(size());
00802     for(int k=0; k<size(); k++)
00803         results[k] = (*this)[k]->getResult();
00804     return results;
00805 }
00806 
00807 Array<Vec> StatsItArray::computeStats(VMat data)
00808 {
00809     int inputsize = data.width();
00810     init(inputsize);
00811 
00812     Vec input(inputsize);
00813     StatsItArray unfinished = *this;
00814 
00815     while(unfinished.size()>0)
00816     {
00817         for(int i=0; i<data.length(); i++)
00818         {
00819             data->getRow(i,input);
00820             unfinished.update(input);
00821         }
00822         unfinished = finish();
00823     }
00824 
00825     return getResults();
00826 }
00827 
00828 } // end of namespace PLearn
00829 
00830 
00831 /*
00832   Local Variables:
00833   mode:c++
00834   c-basic-offset:4
00835   c-file-style:"stroustrup"
00836   c-file-offsets:((innamespace . 0)(inline-open . 0))
00837   indent-tabs-mode:nil
00838   fill-column:79
00839   End:
00840 */
00841 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=79 :
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines