138 lines
3.5 KiB
C++
138 lines
3.5 KiB
C++
/*
|
|
* Copyright (C) 2005 Maarten Keijzer
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of version 2 of the GNU General Public License as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include "TargetInfo.h"
|
|
|
|
using namespace std;
|
|
|
|
TargetInfo::TargetInfo(const TargetInfo& org) { operator=(org); }
|
|
|
|
TargetInfo& TargetInfo::operator=(const TargetInfo& org) {
|
|
_targets.resize(org._targets.size());
|
|
_weights.resize(org._weights.size());
|
|
_tcov_part.resize(org._tcov_part.size());
|
|
|
|
_targets = org._targets;
|
|
_weights = org._weights;
|
|
_tcov_part = org._tcov_part;
|
|
|
|
_tmean = org._tmean;
|
|
_tvar = org._tvar;
|
|
_tstd = org._tstd;
|
|
_tmed = org._tmed;
|
|
return *this;
|
|
}
|
|
|
|
|
|
TargetInfo::TargetInfo(const std::valarray<double>& t) {
|
|
_weights.resize(0);
|
|
_targets.resize(t.size());
|
|
_targets = t;
|
|
|
|
_tmean = _targets.sum()/_targets.size();
|
|
|
|
_tcov_part.resize(_targets.size());
|
|
_tcov_part = _targets;
|
|
_tcov_part -= _tmean;
|
|
|
|
std::valarray<double> tmp = _tcov_part;
|
|
tmp = _tcov_part;
|
|
tmp *= tmp;
|
|
|
|
_tvar = tmp.sum() / (tmp.size()-1);
|
|
_tstd = sqrt(_tvar);
|
|
_tmed = 0;
|
|
}
|
|
|
|
TargetInfo::TargetInfo(const std::valarray<double>& t, const std::valarray<double>& w) {
|
|
|
|
_targets.resize(t.size());
|
|
_weights.resize(w.size());
|
|
|
|
_targets = t;
|
|
_weights = w;
|
|
|
|
double sumw = _weights.sum();
|
|
// scale weights so that they'll add up to 1
|
|
_weights /= sumw;
|
|
|
|
_tmean = (_targets * _weights).sum();
|
|
_tcov_part.resize(_targets.size());
|
|
_tcov_part = _targets;
|
|
_tcov_part -= _tmean;
|
|
|
|
_tvar = (pow(_targets - _tmean, 2.0) * _weights).sum();
|
|
_tstd = sqrt(_tvar);
|
|
_tmed = 0.;
|
|
}
|
|
|
|
// calculate the members, now in the context of a mask
|
|
void TargetInfo::set_training_mask(const std::valarray<bool>& tmask) {
|
|
|
|
TargetInfo tmp;
|
|
|
|
if (has_weights() ) {
|
|
tmp = TargetInfo( _targets[tmask], _weights[tmask]);
|
|
} else {
|
|
tmp = TargetInfo( _targets[tmask] );
|
|
}
|
|
|
|
_tcov_part.resize(tmp._tcov_part.size());
|
|
_tcov_part = tmp._tcov_part;
|
|
|
|
_tmean = tmp._tmean;
|
|
_tvar = tmp._tvar;
|
|
_tstd = tmp._tstd;
|
|
_tmed = tmp._tmed;
|
|
|
|
_training_mask.resize(tmask.size());
|
|
_training_mask = tmask;
|
|
}
|
|
|
|
struct SortOnTargets
|
|
{
|
|
const valarray<double>& t;
|
|
SortOnTargets(const valarray<double>& v) : t(v) {}
|
|
|
|
bool operator()(int i, int j) const {
|
|
return fabs(t[i]) < fabs(t[j]);
|
|
}
|
|
};
|
|
|
|
vector<int> TargetInfo::sort() {
|
|
|
|
vector<int> ind(_targets.size());
|
|
for (unsigned i = 0; i < ind.size(); ++i) { ind[i] = i; }
|
|
|
|
std::sort(ind.begin(), ind.end(), SortOnTargets(_targets));
|
|
|
|
valarray<double> tmptargets = _targets;
|
|
valarray<double> tmpweights = _weights;
|
|
valarray<double> tmpcov = _tcov_part;
|
|
|
|
for (unsigned i = 0; i < ind.size(); ++i)
|
|
{
|
|
_targets[i] = tmptargets[ ind[i] ];
|
|
_tcov_part[i] = tmpcov[ ind[i] ];
|
|
if (_weights.size()) _weights[i] = tmpweights[ ind[i] ];
|
|
}
|
|
|
|
return ind;
|
|
}
|
|
|
|
|
|
|