|
PLearn 0.1
|
The first sentence should be a BRIEF DESCRIPTION of what the class does. More...
#include <PLMathTest.h>


Public Member Functions | |
| PLMathTest () | |
| Default constructor. | |
| virtual string | classname () const |
| virtual OptionList & | getOptionList () const |
| virtual OptionMap & | getOptionMap () const |
| virtual RemoteMethodMap & | getRemoteMethodMap () const |
| virtual PLMathTest * | deepCopy (CopiesMap &copies) const |
| virtual void | build () |
| Post-constructor. | |
| virtual void | makeDeepCopyFromShallowCopy (CopiesMap &copies) |
| Transforms a shallow copy into a deep copy. | |
| virtual void | perform () |
| The method performing the test. | |
Static Public Member Functions | |
| static string | _classname_ () |
| static OptionList & | _getOptionList_ () |
| static RemoteMethodMap & | _getRemoteMethodMap_ () |
| static Object * | _new_instance_for_typemap_ () |
| static bool | _isa_ (const Object *o) |
| static void | _static_initialize_ () |
| static const PPath & | declaringFile () |
Public Attributes | |
| map< string, Vec > | results |
Static Public Attributes | |
| static StaticInitializer | _static_initializer_ |
Static Protected Member Functions | |
| static void | declareOptions (OptionList &ol) |
| Declares the class options. | |
Private Types | |
| typedef PTest | inherited |
Private Member Functions | |
| void | build_ () |
| This does the actual building. | |
The first sentence should be a BRIEF DESCRIPTION of what the class does.
Place the rest of the class programmer documentation here. Doxygen supports Javadoc-style comments. See http://www.doxygen.org/manual.html
Definition at line 61 of file PLMathTest.h.
typedef PTest PLearn::PLMathTest::inherited [private] |
Reimplemented from PLearn::PTest.
Definition at line 63 of file PLMathTest.h.
| PLearn::PLMathTest::PLMathTest | ( | ) |
Default constructor.
Definition at line 60 of file PLMathTest.cc.
{
// ...
// ### You may (or not) want to call build_() to finish building the object
// ### (doing so assumes the parent classes' build_() have been called too
// ### in the parent classes' constructors, something that you must ensure)
}
| string PLearn::PLMathTest::_classname_ | ( | ) | [static] |
Reimplemented from PLearn::PTest.
Definition at line 55 of file PLMathTest.cc.
| OptionList & PLearn::PLMathTest::_getOptionList_ | ( | ) | [static] |
Reimplemented from PLearn::PTest.
Definition at line 55 of file PLMathTest.cc.
| RemoteMethodMap & PLearn::PLMathTest::_getRemoteMethodMap_ | ( | ) | [static] |
Reimplemented from PLearn::PTest.
Definition at line 55 of file PLMathTest.cc.
Reimplemented from PLearn::PTest.
Definition at line 55 of file PLMathTest.cc.
| Object * PLearn::PLMathTest::_new_instance_for_typemap_ | ( | ) | [static] |
Reimplemented from PLearn::PTest.
Definition at line 55 of file PLMathTest.cc.
| StaticInitializer PLMathTest::_static_initializer_ & PLearn::PLMathTest::_static_initialize_ | ( | ) | [static] |
Reimplemented from PLearn::PTest.
Definition at line 55 of file PLMathTest.cc.
| void PLearn::PLMathTest::build | ( | ) | [virtual] |
Post-constructor.
The normal implementation should call simply inherited::build(), then this class's build_(). This method should be callable again at later times, after modifying some option fields to change the "architecture" of the object.
Reimplemented from PLearn::PTest.
Definition at line 73 of file PLMathTest.cc.
{
inherited::build();
build_();
}
| void PLearn::PLMathTest::build_ | ( | ) | [private] |
This does the actual building.
Reimplemented from PLearn::PTest.
Definition at line 117 of file PLMathTest.cc.
{
// ### This method should do the real building of the object,
// ### according to set 'options', in *any* situation.
// ### Typical situations include:
// ### - Initial building of an object from a few user-specified options
// ### - Building of a "reloaded" object: i.e. from the complete set of all serialised options.
// ### - Updating or "re-building" of an object after a few "tuning" options have been modified.
// ### You should assume that the parent class' build_() has already been called.
}
| string PLearn::PLMathTest::classname | ( | ) | const [virtual] |
Reimplemented from PLearn::PTest.
Definition at line 55 of file PLMathTest.cc.
| void PLearn::PLMathTest::declareOptions | ( | OptionList & | ol | ) | [static, protected] |
Declares the class options.
Reimplemented from PLearn::PTest.
Definition at line 99 of file PLMathTest.cc.
References PLearn::OptionBase::buildoption, PLearn::declareOption(), and results.
{
// ### Declare all of this object's options here
// ### For the "flags" of each option, you should typically specify
// ### one of OptionBase::buildoption, OptionBase::learntoption or
// ### OptionBase::tuningoption. Another possible flag to be combined with
// ### is OptionBase::nosave
declareOption(ol, "results", &PLMathTest::results, OptionBase::buildoption,
"Map storing all test results.");
// Now call the parent class' declareOptions
inherited::declareOptions(ol);
}

| static const PPath& PLearn::PLMathTest::declaringFile | ( | ) | [inline, static] |
Reimplemented from PLearn::PTest.
Definition at line 86 of file PLMathTest.h.
:
//##### Protected Options ###############################################
| PLMathTest * PLearn::PLMathTest::deepCopy | ( | CopiesMap & | copies | ) | const [virtual] |
Reimplemented from PLearn::PTest.
Definition at line 55 of file PLMathTest.cc.
| OptionList & PLearn::PLMathTest::getOptionList | ( | ) | const [virtual] |
Reimplemented from PLearn::PTest.
Definition at line 55 of file PLMathTest.cc.
| OptionMap & PLearn::PLMathTest::getOptionMap | ( | ) | const [virtual] |
Reimplemented from PLearn::PTest.
Definition at line 55 of file PLMathTest.cc.
| RemoteMethodMap & PLearn::PLMathTest::getRemoteMethodMap | ( | ) | const [virtual] |
Reimplemented from PLearn::PTest.
Definition at line 55 of file PLMathTest.cc.
| void PLearn::PLMathTest::makeDeepCopyFromShallowCopy | ( | CopiesMap & | copies | ) | [virtual] |
Transforms a shallow copy into a deep copy.
Reimplemented from PLearn::PTest.
Definition at line 82 of file PLMathTest.cc.
References PLERROR.
{
inherited::makeDeepCopyFromShallowCopy(copies);
// ### Call deepCopyField on all "pointer-like" fields
// ### that you wish to be deepCopied rather than
// ### shallow-copied.
// ### ex:
// deepCopyField(trainvec, copies);
// ### Remove this line when you have fully implemented this method.
PLERROR("PLMathTest::makeDeepCopyFromShallowCopy not fully (correctly) implemented yet!");
}
| void PLearn::PLMathTest::perform | ( | ) | [virtual] |
The method performing the test.
A typical test consists in some output (to pout and / or perr), and updates of this object's options.
Reimplemented from PLearn::PTest.
Definition at line 131 of file PLMathTest.cc.
References PLearn::TVec< T >::append(), PLearn::PRandom::common(), PLearn::d_hinge_loss(), PLearn::d_soft_slope(), PLearn::dilogarithm(), DOUBLE_TO_INT, PLearn::exp(), PLearn::FABS(), PLearn::fastsigmoid(), PLearn::fasttanh(), PLearn::PStream::flush(), PLearn::hard_slope(), PLearn::hard_slope_integral(), PLearn::hinge_loss(), i, PLearn::inverse_sigmoid(), PLearn::inverse_softplus(), PLearn::ipow(), PLearn::is_equal(), PLearn::is_integer(), PLearn::is_missing(), PLearn::is_positive(), j, PLearn::TVec< T >::length(), PLearn::log(), PLearn::logadd(), PLearn::logsub(), PLearn::logtwo(), MISSING_VALUE, PLearn::mypow(), n, PLearn::n_choose(), PLearn::negative(), PLearn::openString(), pl_log, PLearn::PStream::plearn_ascii, PLearn::positive(), PLearn::safeexp(), PLearn::safeflog(), PLearn::safeflog2(), PLearn::safelog(), PLearn::sigmoid(), PLearn::sign(), PLearn::soft_slope(), PLearn::soft_slope_integral(), PLearn::softplus(), PLearn::softplus_primitive(), PLearn::sqrt(), PLearn::square(), PLearn::tabulated_soft_slope(), PLearn::tabulated_soft_slope_integral(), PLearn::tabulated_softplus(), PLearn::tabulated_softplus_primitive(), PLearn::tanh(), PLearn::ultrafastsigmoid(), PLearn::ultrafasttanh(), and x.
{
int n = 20;
TVec<int> bounds;
string bounds_str = "[ 1 10 50 1000 ]";
PStream read_bounds = openString(bounds_str, PStream::plearn_ascii);
read_bounds >> bounds;
read_bounds.flush();
Vec samples;
Vec vec(n);
for (int i = 0; i < bounds.length(); i++) {
PRandom::common(false)->fill_random_uniform(vec,-bounds[i],bounds[i]);
samples.append(vec);
}
samples.append(0);
samples.append(1);
samples.append(-1);
samples.append(MISSING_VALUE);
samples.append(INFINITY);
samples.append(-INFINITY);
PP<ProgressBar> pb = new ProgressBar("Performing tests", samples.length());
for (int i = 0; i < samples.length(); i++) {
int j;
real x = samples[i];
results["data"].append(x);
DOUBLE_TO_INT(x, j);
results["DOUBLE_TO_INT"].append(j);
results["sign"].append(sign(x));
results["positive"].append(positive(x));
results["negative"].append(negative(x));
results["is_equal_1.00000001"].append(is_equal(x, x * 1.00000001));
results["is_equal_1.001"].append(is_equal(x, x * 1.001));
results["square"].append(square(x));
results["hinge_loss_1"].append(hinge_loss(x, 1));
results["d_hinge_loss_1"].append(d_hinge_loss(x, 1));
results["is_missing"].append(is_missing(x));
results["is_integer"].append(is_integer(x));
results["FABS"].append(FABS(x));
results["mypow"].append(mypow(x,x));
if (int(x) >= 0) {
results["ipow_real"].append(ipow(x,int(x)));
results["ipow_int"].append(ipow(int(x),int(x)));
} else {
results["ipow_real"].append(0);
results["ipow_int"].append(0);
}
results["sigmoid"].append(sigmoid(x));
results["is_positive"].append(is_positive(x));
if (x >= 0 && x <= 1)
results["inverse_sigmoid"].append(inverse_sigmoid(x));
else
results["inverse_sigmoid"].append(0);
results["softplus"].append(softplus(x));
results["inverse_softplus"].append(inverse_softplus(x));
results["hard_slope"].append(hard_slope(x));
results["soft_slope"].append(soft_slope(x));
results["d_soft_slope"].append(d_soft_slope(x));
results["n_choose"].append(n_choose(int(x), int(x) + 2));
if (x >= 0) {
results["safelog"].append(safelog(x));
results["safeflog"].append(safeflog(x));
results["safeflog"].append(safeflog(x, x + 3));
results["safeflog2"].append(safeflog2(x));
} else {
results["safelog"].append(0);
results["safeflog"].append(0);
results["safeflog"].append(0);
results["safeflog2"].append(0);
}
results["sqrt"].append(sqrt(x));
results["tanh"].append(tanh(x));
results["exp"].append(exp(x));
results["safeexp"].append(safeexp(x));
results["pl_log"].append(pl_log(x));
results["log_a_b"].append(log(x, x + 3));
results["logtwo"].append(logtwo(x));
results["logadd"].append(logadd(x, x + 2));
if (!is_missing(x) && !isinf(x)) {
results["logsub"].append(logsub(x, x - 1));
results["dilogarithm"].append(dilogarithm(x));
results["fasttanh"].append(fasttanh(x));
results["fastsigmoid"].append(fastsigmoid(x));
results["ultrafasttanh"].append(ultrafasttanh(x));
results["ultrafastsigmoid"].append(ultrafastsigmoid(x));
results["tabulated_softplus"].append(tabulated_softplus(x));
results["tabulated_soft_slope"].append(tabulated_soft_slope(x));
} else {
results["logsub"].append(0);
results["dilogarithm"].append(0);
results["fasttanh"].append(0);
results["fastsigmoid"].append(0);
results["ultrafasttanh"].append(0);
results["ultrafastsigmoid"].append(0);
results["tabulated_softplus"].append(0);
results["tabulated_soft_slope"].append(0);
}
if (FABS(x) < 100) {
results["softplus_primitive"].append(softplus_primitive(x));
results["tabulated_softplus_primitive"].append(tabulated_softplus_primitive(x));
results["hard_slope_integral"].append(hard_slope_integral(x));
results["soft_slope_integral"].append(soft_slope_integral(x));
results["tabulated_soft_slope_integral"].append(tabulated_soft_slope_integral(x));
} else {
results["softplus_primitive"].append(0);
results["tabulated_softplus_primitive"].append(0);
results["hard_slope_integral"].append(0);
results["soft_slope_integral"].append(0);
results["tabulated_soft_slope_integral"].append(0);
}
if (pb)
pb->update(i + 1);
}
}

Reimplemented from PLearn::PTest.
Definition at line 86 of file PLMathTest.h.
| map<string, Vec> PLearn::PLMathTest::results |
Definition at line 68 of file PLMathTest.h.
Referenced by declareOptions().
1.7.4