RandomVariable Struct Reference

#include <qle/math/randomvariable.hpp>

Collaboration diagram for RandomVariable:

Public Member Functions
	~RandomVariable ()
	RandomVariable ()
	RandomVariable (const RandomVariable &r)
	RandomVariable (RandomVariable &&r)
RandomVariable &	operator= (const RandomVariable &r)
RandomVariable &	operator= (RandomVariable &&r)
	RandomVariable (const Size n, const Real value=0.0, const Real time=Null< Real >())
	RandomVariable (const Filter &f, const Real valueTrue=1.0, const Real valueFalse=0.0, const Real time=Null< Real >())
	RandomVariable (const Size n, const Real *const data, const Real time=Null< Real >())
	RandomVariable (const std::vector< double > &data, const Real time=Null< Real >())
	RandomVariable (const QuantLib::Array &data, const Real time=Null< Real >())
void	copyToMatrixCol (QuantLib::Matrix &, const Size j) const
void	copyToArray (QuantLib::Array &array) const
void	clear ()
void	set (const Size i, const Real v)
void	setTime (const Real time)
void	setAll (const Real v)
void	resetSize (const Size n)
bool	deterministic () const
void	updateDeterministic ()
bool	initialised () const
Size	size () const
Real	operator[] (const Size i) const
Real	at (const Size i) const
Real	time () const
RandomVariable &	operator+= (const RandomVariable &)
RandomVariable &	operator-= (const RandomVariable &)
RandomVariable &	operator*= (const RandomVariable &)
RandomVariable &	operator/= (const RandomVariable &)
void	expand ()
double *	data ()

Static Public Attributes
static std::function< void(RandomVariable &)>	deleter

Private Member Functions
void	checkTimeConsistencyAndUpdate (const Real t)

Private Attributes
Size	n_
double	constantData_
double *	data_
bool	deterministic_
Real	time_

Friends
bool	operator== (const RandomVariable &, const RandomVariable &)
RandomVariable	operator+ (RandomVariable, const RandomVariable &)
RandomVariable	operator- (RandomVariable, const RandomVariable &)
RandomVariable	operator* (RandomVariable, const RandomVariable &)
RandomVariable	operator/ (RandomVariable, const RandomVariable &)
RandomVariable	max (RandomVariable, const RandomVariable &)
RandomVariable	min (RandomVariable, const RandomVariable &)
RandomVariable	pow (RandomVariable, const RandomVariable &)
RandomVariable	operator- (RandomVariable)
RandomVariable	abs (RandomVariable)
RandomVariable	exp (RandomVariable)
RandomVariable	log (RandomVariable)
RandomVariable	sqrt (RandomVariable)
RandomVariable	sin (RandomVariable)
RandomVariable	cos (RandomVariable)
RandomVariable	normalCdf (RandomVariable)
RandomVariable	normalPdf (RandomVariable)
Filter	close_enough (const RandomVariable &, const RandomVariable &)
Filter	operator< (const RandomVariable &, const RandomVariable &)
Filter	operator<= (const RandomVariable &, const RandomVariable &)
Filter	operator> (const RandomVariable &, const RandomVariable &)
Filter	operator>= (const RandomVariable &, const RandomVariable &)
bool	close_enough_all (const RandomVariable &, const RandomVariable &)
RandomVariable	applyFilter (RandomVariable, const Filter &)
RandomVariable	applyInverseFilter (RandomVariable, const Filter &)
RandomVariable	conditionalResult (const Filter &, RandomVariable, const RandomVariable &)
RandomVariable	indicatorEq (RandomVariable, const RandomVariable &, const Real trueVal, const Real falseVal)
RandomVariable	indicatorGt (RandomVariable, const RandomVariable &, const Real trueVal, const Real falseVal, const Real eps)
RandomVariable	indicatorGeq (RandomVariable, const RandomVariable &, const Real trueVal, const Real falseVal, const Real eps)

Detailed Description

Definition at line 152 of file randomvariable.hpp.

Constructor & Destructor Documentation

~RandomVariable()

~RandomVariable

(

)

Definition at line 310 of file randomvariable.cpp.

{ clear(); }

Here is the call graph for this function:

RandomVariable() [1/8]

RandomVariable

(

)

Definition at line 312 of file randomvariable.cpp.

    : n_(0), constantData_(0.0), data_(nullptr), deterministic_(false), time_(Null<Real>()) {}

RandomVariable() [2/8]

RandomVariable

(

const RandomVariable &

r

)

Definition at line 315 of file randomvariable.cpp.

                                                      {
    n_ = r.n_;
    constantData_ = r.constantData_;
    if (r.data_) {
        resumeDataStats();
        data_ = new double[n_];
        // std::memcpy(data_, r.data_, n_ * sizeof(double));
        std::copy(r.data_, r.data_ + n_, data_);
        stopDataStats(n_);
    } else {
        data_ = nullptr;
    }
    deterministic_ = r.deterministic_;
    time_ = r.time_;
}

RandomVariable() [3/8]

RandomVariable

(

RandomVariable &&

r

)

Definition at line 331 of file randomvariable.cpp.

                                                 {
    n_ = r.n_;
    constantData_ = r.constantData_;
    data_ = r.data_;
    r.data_ = nullptr;
    deterministic_ = r.deterministic_;
    time_ = r.time_;
}

RandomVariable() [4/8]

RandomVariable ( const Size  n, const Real  value = 0.0, const Real  time = Null<Real>()  )

explicit

Definition at line 385 of file randomvariable.cpp.

    : n_(n), constantData_(value), data_(nullptr), deterministic_(n != 0), time_(time) {}

RandomVariable() [5/8]

RandomVariable ( const Filter &  f, const Real  valueTrue = 1.0, const Real  valueFalse = 0.0, const Real  time = Null<Real>()  )

explicit

Definition at line 388 of file randomvariable.cpp.

                                                                                                            {
    if (!f.initialised()) {
        data_ = nullptr;
        clear();
        return;
    }
    n_ = f.size();
    if (f.deterministic()) {
        data_ = nullptr;
        setAll(f.at(0) ? valueTrue : valueFalse);
    } else {
        resumeDataStats();
        constantData_ = 0.0;
        deterministic_ = false;
        data_ = new double[n_];
        for (Size i = 0; i < n_; ++i)
            set(i, f[i] ? valueTrue : valueFalse);
        stopDataStats(n_);
    }
    time_ = time;
}

Here is the call graph for this function:

RandomVariable() [6/8]

RandomVariable ( const Size  n, const Real *const  data, const Real  time = Null<Real>()  )

explicit

Definition at line 410 of file randomvariable.cpp.

                                                                                    {
    n_ = n;
    deterministic_ = false;
    time_ = time;
    if (n_ != 0) {
        resumeDataStats();
        data_ = new double[n_];
        // std::memcpy(data_, array.begin(), n_ * sizeof(double));
        std::copy(data, data + n_, data_);
        stopDataStats(n_);
    } else {
        data_ = nullptr;
    }
    constantData_ = 0.0;
}

Here is the call graph for this function:

RandomVariable() [7/8]

RandomVariable ( const std::vector< double > &  data, const Real  time = Null< Real >()  )

explicit

Here is the call graph for this function:

RandomVariable() [8/8]

RandomVariable ( const QuantLib::Array &  data, const Real  time = Null<Real>()  )

explicit

Definition at line 429 of file randomvariable.cpp.

    : RandomVariable(data.size(), data.begin(), time) {}

Member Function Documentation

operator=() [1/2]

RandomVariable & operator=

(

const RandomVariable &

r

)

Definition at line 340 of file randomvariable.cpp.

                                                                 {
    if (r.deterministic_) {
        deterministic_ = true;
        if (data_) {
            delete[] data_;
            data_ = nullptr;
        }
    } else {
        deterministic_ = false;
        if (r.n_ != 0) {
            resumeDataStats();
            if (n_ != r.n_) {
                if (data_)
                    delete[] data_;
                data_ = new double[r.n_];
            }
            // std::memcpy(data_, r.data_, r.n_ * sizeof(double));
            std::copy(r.data_, r.data_ + r.n_, data_);
            stopDataStats(r.n_);
        } else {
            if (data_) {
                delete[] data_;
                data_ = nullptr;
            }
        }
    }
    n_ = r.n_;
    constantData_ = r.constantData_;
    time_ = r.time_;
    return *this;
}

operator=() [2/2]

RandomVariable & operator=

(

RandomVariable &&

r

)

Definition at line 372 of file randomvariable.cpp.

                                                            {
    n_ = r.n_;
    constantData_ = r.constantData_;
    if (data_) {
        delete[] data_;
    }
    data_ = r.data_;
    r.data_ = nullptr;
    deterministic_ = r.deterministic_;
    time_ = r.time_;
    return *this;
}

copyToMatrixCol()

void copyToMatrixCol	(	QuantLib::Matrix &	m,
		const Size	j
	)		const

Definition at line 432 of file randomvariable.cpp.

                                                                          {
    if (deterministic_)
        std::fill(m.column_begin(j), std::next(m.column_end(j), n_), constantData_);
    else if (n_ != 0) {
        resumeDataStats();
        std::copy(data_, data_ + n_, m.column_begin(j));
        stopDataStats(n_);
    }
}

Here is the caller graph for this function:

copyToArray()

void copyToArray

(

QuantLib::Array &

array

)

const

Definition at line 442 of file randomvariable.cpp.

                                                           {
    if (deterministic_)
        std::fill(array.begin(), array.end(), constantData_);
    else if (n_ != 0) {
        resumeDataStats();
        // std::memcpy(array.begin(), data_, n_ * sizeof(double));
        std::copy(data_, data_ + n_, array.begin());
        stopDataStats(n_);
    }
}

Here is the caller graph for this function:

clear()

void clear

(

)

Definition at line 453 of file randomvariable.cpp.

                           {
    n_ = 0;
    constantData_ = 0.0;
    if (data_) {
        delete[] data_;
        data_ = nullptr;
    }
    deterministic_ = false;
    time_ = Null<Real>();
}

Here is the caller graph for this function:

set()

void set	(	const Size	i,
		const Real	v
	)

Definition at line 346 of file randomvariable.hpp.

                                                          {
    QL_REQUIRE(i < n_, "RandomVariable::set(" << i << "): out of bounds, size is " << n_);
    if (deterministic_) {
        if (!QuantLib::close_enough(v, constantData_)) {
            expand();
        } else {
            return;
        }
    }
    data_[i] = v;
}

Here is the call graph for this function:

Here is the caller graph for this function:

setTime()

void setTime

(

const Real

time

)

Definition at line 174 of file randomvariable.hpp.

{ time_ = std::max(time, 0.0); }

Here is the call graph for this function:

setAll()

void setAll

(

const Real

v

)

Definition at line 478 of file randomvariable.cpp.

                                        {
    QL_REQUIRE(n_ > 0, "RandomVariable::setAll(): dimension is zero");
    if (data_) {
        delete[] data_;
        data_ = nullptr;
    }
    constantData_ = v;
    deterministic_ = true;
}

Here is the caller graph for this function:

resetSize()

void resetSize

(

const Size

n

)

Definition at line 488 of file randomvariable.cpp.

                                           {
    QL_REQUIRE(deterministic_, "RandomVariable::resetSize(): only possible for deterministic variables.");
    n_ = n;
}

deterministic()

bool deterministic

(

)

const

Definition at line 180 of file randomvariable.hpp.

{ return deterministic_; }

Here is the caller graph for this function:

updateDeterministic()

void updateDeterministic

(

)

Definition at line 464 of file randomvariable.cpp.

                                         {
    if (deterministic_ || !initialised())
        return;
    for (Size i = 0; i < n_; ++i) {
        resumeCalcStats();
        if (!QuantLib::close_enough(data_[i], constantData_)) {
            stopCalcStats(i);
            return;
        }
    }
    setAll(constantData_);
    stopCalcStats(n_);
}

Here is the call graph for this function:

initialised()

bool initialised

(

)

const

Definition at line 182 of file randomvariable.hpp.

{ return n_ != 0; }

Here is the caller graph for this function:

size()

Size size

(

)

const

Definition at line 183 of file randomvariable.hpp.

{ return n_; }

Here is the caller graph for this function:

operator[]()

Real operator[]

(

const Size

i

)

const

Definition at line 358 of file randomvariable.hpp.

                                                         {
    if (deterministic_)
        return constantData_;
    else
        return data_[i];
}

Here is the caller graph for this function:

at()

Real at

(

const Size

i

)

const

Definition at line 365 of file randomvariable.hpp.

                                                 {
    QL_REQUIRE(n_ > 0, "RandomVariable::at(" << i << "): dimension is zero");
    if (deterministic_)
        return constantData_;
    QL_REQUIRE(i < n_, "RandomVariable::at(" << i << "): out of bounds, size is " << n_);
    return operator[](i);
}

Here is the call graph for this function:

Here is the caller graph for this function:

time()

Real time

(

)

const

Definition at line 186 of file randomvariable.hpp.

{ return time_; }

Here is the caller graph for this function:

operator+=()

RandomVariable & operator+=

(

const RandomVariable &

y

)

Definition at line 533 of file randomvariable.cpp.

                                                                  {
    if (!y.initialised())
        clear();
    if (!initialised())
        return *this;
    QL_REQUIRE(size() == y.size(),
               "RandomVariable: x += y: x size (" << size() << ") must be equal to y size (" << y.size() << ")");
    checkTimeConsistencyAndUpdate(y.time());
    if (!y.deterministic_)
        expand();
    else if (QuantLib::close_enough(y.constantData_, 0.0))
        return *this;
    if (deterministic_)
        constantData_ += y.constantData_;
    else {
        resumeCalcStats();
        for (Size i = 0; i < n_; ++i) {
            data_[i] += y[i];
        }
        stopCalcStats(n_);
    }
    return *this;
}

Here is the call graph for this function:

operator-=()

RandomVariable & operator-=

(

const RandomVariable &

y

)

Definition at line 557 of file randomvariable.cpp.

                                                                  {
    if (!y.initialised())
        clear();
    if (!initialised())
        return *this;
    QL_REQUIRE(size() == y.size(),
               "RandomVariable: x -= y: x size (" << size() << ") must be equal to y size (" << y.size() << ")");
    checkTimeConsistencyAndUpdate(y.time());
    if (!y.deterministic_)
        expand();
    else if (QuantLib::close_enough(y.constantData_, 0.0))
        return *this;
    if (deterministic_)
        constantData_ -= y.constantData_;
    else {
        resumeCalcStats();
        for (Size i = 0; i < n_; ++i) {
            data_[i] -= y[i];
        }
        stopCalcStats(n_);
    }
    return *this;
}

Here is the call graph for this function:

operator*=()

RandomVariable & operator*=

(

const RandomVariable &

y

)

Definition at line 581 of file randomvariable.cpp.

                                                                  {
    if (!y.initialised())
        clear();
    if (!initialised())
        return *this;
    QL_REQUIRE(size() == y.size(),
               "RandomVariable: x *= y: x size (" << size() << ") must be equal to y size (" << y.size() << ")");
    checkTimeConsistencyAndUpdate(y.time());
    if (!y.deterministic_)
        expand();
    else if (QuantLib::close_enough(y.constantData_, 1.0))
        return *this;
    if (deterministic_)
        constantData_ *= y.constantData_;
    else {
        resumeCalcStats();
        for (Size i = 0; i < n_; ++i) {
            data_[i] *= y[i];
        }
        stopCalcStats(n_);
    }
    return *this;
}

Here is the call graph for this function:

operator/=()

RandomVariable & operator/=

(

const RandomVariable &

y

)

Definition at line 605 of file randomvariable.cpp.

                                                                  {
    if (!y.initialised())
        clear();
    if (!initialised())
        return *this;
    QL_REQUIRE(size() == y.size(),
               "RandomVariable: x /= y: x size (" << size() << ") must be equal to y size (" << y.size() << ")");
    checkTimeConsistencyAndUpdate(y.time());
    if (!y.deterministic_)
        expand();
    else if (QuantLib::close_enough(y.constantData_, 1.0))
        return *this;
    if (deterministic_)
        constantData_ /= y.constantData_;
    else {
        resumeCalcStats();
        for (Size i = 0; i < n_; ++i) {
            data_[i] /= y[i];
        }
        stopCalcStats(n_);
    }
    return *this;
}

Here is the call graph for this function:

expand()

void expand

(

)

Definition at line 493 of file randomvariable.cpp.

                            {
    if (!deterministic_)
        return;
    deterministic_ = false;
    resumeDataStats();
    data_ = new double[n_];
    std::fill(data_, data_ + n_, constantData_);
    stopDataStats(n_);
}

Here is the caller graph for this function:

data()

double * data

(

)

Definition at line 373 of file randomvariable.hpp.

{ return data_; }

Here is the caller graph for this function:

checkTimeConsistencyAndUpdate()

void checkTimeConsistencyAndUpdate ( const Real  t )

private

Definition at line 503 of file randomvariable.cpp.

                                                               {
    QL_REQUIRE((time_ == Null<Real>() || t == Null<Real>()) || QuantLib::close_enough(time_, t),
               "RandomVariable: inconsistent times " << time_ << " and " << t);
    if (time_ == Null<Real>())
        time_ = t;
}

Here is the caller graph for this function:

Friends And Related Function Documentation

operator==

bool operator== ( const RandomVariable &  , const RandomVariable &    )

friend

Definition at line 515 of file randomvariable.cpp.

                                                                  {
    if (a.size() != b.size())
        return false;
    if (a.deterministic_ && b.deterministic_) {
        return a.constantData_ == b.constantData_;
    } else {
        resumeCalcStats();
        for (Size j = 0; j < a.size(); ++j)
            if (a[j] != b[j]) {
                stopCalcStats(j);
                return false;
            }
    }
    return QuantLib::close_enough(a.time(), b.time());
}

operator+

RandomVariable operator+ ( RandomVariable  , const RandomVariable &    )

friend

Definition at line 629 of file randomvariable.cpp.

                                                                    {
    if (!x.initialised() || !y.initialised())
        return RandomVariable();
    x += y;
    return x;
}

operator- [1/2]

RandomVariable operator- ( RandomVariable  , const RandomVariable &    )

friend

Definition at line 636 of file randomvariable.cpp.

                                                                    {
    if (!x.initialised() || !y.initialised())
        return RandomVariable();
    x -= y;
    return x;
}

operator*

RandomVariable operator* ( RandomVariable  , const RandomVariable &    )

friend

Definition at line 643 of file randomvariable.cpp.

                                                                    {
    if (!x.initialised() || !y.initialised())
        return RandomVariable();
    x *= y;
    return x;
}

operator/

RandomVariable operator/ ( RandomVariable  , const RandomVariable &    )

friend

Definition at line 650 of file randomvariable.cpp.

                                                                    {
    if (!x.initialised() || !y.initialised())
        return RandomVariable();
    x /= y;
    return x;
}

max

RandomVariable max ( RandomVariable  , const RandomVariable &    )

friend

Definition at line 657 of file randomvariable.cpp.

                                                              {
    if (!x.initialised() || !y.initialised())
        return RandomVariable();
    QL_REQUIRE(x.size() == y.size(),
               "RandomVariable: max(x,y): x size (" << x.size() << ") must be equal to y size (" << y.size() << ")");
    x.checkTimeConsistencyAndUpdate(y.time());
    if (!y.deterministic_)
        x.expand();
    if (x.deterministic())
        x.constantData_ = std::max(x.constantData_, y.constantData_);
    else {
        resumeCalcStats();
        for (Size i = 0; i < x.size(); ++i) {
            x.data_[i] = std::max(x.data_[i], y[i]);
        }
        stopCalcStats(x.size());
    }
    return x;
}

min

RandomVariable min ( RandomVariable  , const RandomVariable &    )

friend

Definition at line 677 of file randomvariable.cpp.

                                                              {
    if (!x.initialised() || !y.initialised())
        return RandomVariable();
    QL_REQUIRE(x.size() == y.size(),
               "RandomVariable: min(x,y): x size (" << x.size() << ") must be equal to y size (" << y.size() << ")");
    x.checkTimeConsistencyAndUpdate(y.time());
    if (!y.deterministic_)
        x.expand();
    if (x.deterministic())
        x.constantData_ = std::min(x.constantData_, y.constantData_);
    else {
        resumeCalcStats();
        for (Size i = 0; i < x.size(); ++i) {
            x.data_[i] = std::min(x.data_[i], y[i]);
        }
        stopCalcStats(x.size());
    }
    return x;
}

pow

RandomVariable pow ( RandomVariable  , const RandomVariable &    )

friend

Definition at line 697 of file randomvariable.cpp.

                                                              {
    if (!x.initialised() || !y.initialised())
        return RandomVariable();
    QL_REQUIRE(x.size() == y.size(),
               "RandomVariable: pow(x,y): x size (" << x.size() << ") must be equal to y size (" << y.size() << ")");
    x.checkTimeConsistencyAndUpdate(y.time());
    if (!y.deterministic_)
        x.expand();
    else if (QuantLib::close_enough(y.constantData_, 1.0))
        return x;
    if (x.deterministic())
        x.constantData_ = std::pow(x.constantData_, y.constantData_);
    else {
        resumeCalcStats();
        for (Size i = 0; i < x.size(); ++i) {
            x.data_[i] = std::pow(x.data_[i], y[i]);
        }
        stopCalcStats(x.size());
    }
    return x;
}

operator- [2/2]

RandomVariable operator- ( RandomVariable  )

friend

Definition at line 719 of file randomvariable.cpp.

                                           {
    if (x.deterministic_)
        x.constantData_ = -x.constantData_;
    else {
        resumeCalcStats();
        for (Size i = 0; i < x.n_; ++i) {
            x.data_[i] = -x.data_[i];
        }
        stopCalcStats(x.n_);
    }
    return x;
}

abs

RandomVariable abs ( RandomVariable  )

friend

Definition at line 732 of file randomvariable.cpp.

                                     {
    if (x.deterministic_)
        x.constantData_ = std::abs(x.constantData_);
    else {
        resumeCalcStats();
        for (Size i = 0; i < x.n_; ++i) {
            x.data_[i] = std::abs(x.data_[i]);
        }
        stopCalcStats(x.n_);
    }
    return x;
}

exp

RandomVariable exp ( RandomVariable  )

friend

Definition at line 745 of file randomvariable.cpp.

                                     {
    if (x.deterministic_)
        x.constantData_ = std::exp(x.constantData_);
    else {
        resumeCalcStats();
        for (Size i = 0; i < x.n_; ++i) {
            x.data_[i] = std::exp(x.data_[i]);
        }
        stopCalcStats(x.n_);
    }
    return x;
}

log

RandomVariable log ( RandomVariable  )

friend

Definition at line 758 of file randomvariable.cpp.

                                     {
    if (x.deterministic_)
        x.constantData_ = std::log(x.constantData_);
    else {
        resumeCalcStats();
        for (Size i = 0; i < x.n_; ++i) {
            x.data_[i] = std::log(x.data_[i]);
        }
        stopCalcStats(x.n_);
    }
    return x;
}

sqrt

RandomVariable sqrt ( RandomVariable  )

friend

Definition at line 771 of file randomvariable.cpp.

                                      {
    if (x.deterministic_)
        x.constantData_ = std::sqrt(x.constantData_);
    else {
        resumeCalcStats();
        for (Size i = 0; i < x.n_; ++i) {
            x.data_[i] = std::sqrt(x.data_[i]);
        }
        stopCalcStats(x.n_);
    }
    return x;
}

sin

RandomVariable sin ( RandomVariable  )

friend

Definition at line 784 of file randomvariable.cpp.

                                     {
    if (x.deterministic_)
        x.constantData_ = std::sin(x.constantData_);
    else {
        resumeCalcStats();
        for (Size i = 0; i < x.n_; ++i) {
            x.data_[i] = std::sin(x.data_[i]);
        }
        stopCalcStats(x.n_);
    }
    return x;
}

cos

RandomVariable cos ( RandomVariable  )

friend

Definition at line 797 of file randomvariable.cpp.

                                     {
    if (x.deterministic_)
        x.constantData_ = std::cos(x.constantData_);
    else {
        resumeCalcStats();
        for (Size i = 0; i < x.n_; ++i) {
            x.data_[i] = std::cos(x.data_[i]);
        }
        stopCalcStats(x.n_);
    }
    return x;
}

normalCdf

RandomVariable normalCdf ( RandomVariable  )

friend

Definition at line 810 of file randomvariable.cpp.

                                           {
    static const boost::math::normal_distribution<double> n;
    if (x.deterministic_)
        x.constantData_ = boost::math::cdf(n, x.constantData_);
    else {
        resumeCalcStats();
        for (Size i = 0; i < x.n_; ++i) {
            x.data_[i] = boost::math::cdf(n, x.data_[i]);
        }
        stopCalcStats(x.n_);
    }
    return x;
}

normalPdf

RandomVariable normalPdf ( RandomVariable  )

friend

Definition at line 824 of file randomvariable.cpp.

                                           {
    static const boost::math::normal_distribution<double> n;
    if (x.deterministic_)
        x.constantData_ = boost::math::pdf(n, x.constantData_);
    else {
        resumeCalcStats();
        for (Size i = 0; i < x.n_; ++i) {
            x.data_[i] = boost::math::pdf(n, x.data_[i]);
        }
        stopCalcStats(x.n_);
    }
    return x;
}

close_enough

Filter close_enough ( const RandomVariable &  , const RandomVariable &    )

friend

Definition at line 838 of file randomvariable.cpp.

                                                                      {
    if (!x.initialised() || !y.initialised())
        return Filter();
    QL_REQUIRE(x.size() == y.size(), "RandomVariable: close_enough(x,y): x size ("
                                         << x.size() << ") must be equal to y size (" << y.size() << ")");
    checkTimeConsistency(x, y);
    if (x.deterministic_ && y.deterministic_) {
        return Filter(x.size(), QuantLib::close_enough(x.constantData_, y.constantData_));
    }
    resumeCalcStats();
    Filter result(x.size(), false);
    for (Size i = 0; i < x.size(); ++i) {
        result.set(i, QuantLib::close_enough(x[i], y[i]));
    }
    stopCalcStats(x.size());
    return result;
}

operator<

Filter operator< ( const RandomVariable &  x, const RandomVariable &  y  )

friend

Definition at line 988 of file randomvariable.cpp.

                                                                   {
    if (!x.initialised() || !y.initialised())
        return Filter();
    QL_REQUIRE(x.size() == y.size(),
               "RandomVariable: x < y: x size (" << x.size() << ") must be equal to y size (" << y.size() << ")");
    checkTimeConsistency(x, y);
    if (x.deterministic_ && y.deterministic_) {
        return Filter(x.size(),
                      x.constantData_ < y.constantData_ && !QuantLib::close_enough(x.constantData_, y.constantData_));
    }
    resumeCalcStats();
    Filter result(x.size(), false);
    for (Size i = 0; i < x.size(); ++i) {
        result.set(i, x[i] < y[i] && !QuantLib::close_enough(x[i], y[i]));
    }
    stopCalcStats(x.size());
    return result;
}

operator<=

Filter operator<= ( const RandomVariable &  x, const RandomVariable &  y  )

friend

Definition at line 1007 of file randomvariable.cpp.

                                                                    {
    if (!x.initialised() || !y.initialised())
        return Filter();
    QL_REQUIRE(x.size() == y.size(),
               "RandomVariable: x <= y: x size (" << x.size() << ") must be equal to y size (" << y.size() << ")");
    checkTimeConsistency(x, y);
    if (x.deterministic_ && y.deterministic_) {
        return Filter(x.size(),
                      x.constantData_ < y.constantData_ || QuantLib::close_enough(x.constantData_, y.constantData_));
    }
    resumeCalcStats();
    Filter result(x.size(), false);
    for (Size i = 0; i < x.size(); ++i) {
        result.set(i, x[i] < y[i] || QuantLib::close_enough(x[i], y[i]));
    }
    stopCalcStats(x.size());
    return result;
}

operator>

Filter operator> ( const RandomVariable &  x, const RandomVariable &  y  )

friend

Definition at line 1026 of file randomvariable.cpp.

                                                                   {
    if (!x.initialised() || !y.initialised())
        return Filter();
    QL_REQUIRE(x.size() == y.size(),
               "RandomVariable: x > y: x size (" << x.size() << ") must be equal to y size (" << y.size() << ")");
    checkTimeConsistency(x, y);
    if (x.deterministic_ && y.deterministic_) {
        return Filter(x.size(),
                      x.constantData_ > y.constantData_ && !QuantLib::close_enough(x.constantData_, y.constantData_));
    }
    Filter result(x.size(), false);
    for (Size i = 0; i < x.size(); ++i) {
        result.set(i, x[i] > y[i] && !QuantLib::close_enough(x[i], y[i]));
    }
    return result;
}

operator>=

Filter operator>= ( const RandomVariable &  x, const RandomVariable &  y  )

friend

Definition at line 1043 of file randomvariable.cpp.

                                                                    {
    if (!x.initialised() || !y.initialised())
        return Filter();
    QL_REQUIRE(x.size() == y.size(),
               "RandomVariable: x >= y: x size (" << x.size() << ") must be equal to y size (" << y.size() << ")");
    checkTimeConsistency(x, y);
    if (x.deterministic_ && y.deterministic_) {
        return Filter(x.size(),
                      x.constantData_ > y.constantData_ || QuantLib::close_enough(x.constantData_, y.constantData_));
    }
    resumeCalcStats();
    Filter result(x.size(), false);
    for (Size i = 0; i < x.size(); ++i) {
        result.set(i, x[i] > y[i] || QuantLib::close_enough(x[i], y[i]));
    }
    stopCalcStats(x.size());
    return result;
}

close_enough_all

bool close_enough_all ( const RandomVariable &  , const RandomVariable &    )

friend

Definition at line 856 of file randomvariable.cpp.

                                                                        {
    QL_REQUIRE(x.size() == y.size(), "RandomVariable: close_enough_all(x,y): x size ("
                                         << x.size() << ") must be equal to y size (" << y.size() << ")");
    checkTimeConsistency(x, y);
    if (x.deterministic_ && y.deterministic_) {
        return QuantLib::close_enough(x.constantData_, y.constantData_);
    }
    resumeCalcStats();
    for (Size i = 0; i < x.size(); ++i) {
        if (!QuantLib::close_enough(x[i], y[i]))
            return false;
    }
    stopCalcStats(x.size());
    return true;
}

applyFilter

RandomVariable applyFilter ( RandomVariable  , const Filter &    )

friend

Definition at line 1062 of file randomvariable.cpp.

                                                              {
    if (!x.initialised())
        return x;
    QL_REQUIRE(!f.initialised() || f.size() == x.size(), "RandomVariable: applyFitler(x,f): filter size ("
                                                             << f.size() << ") must be equal to x size (" << x.size()
                                                             << ")");
    if (!f.initialised())
        return x;
    if (f.deterministic()) {
        if (!f[0])
            return RandomVariable(x.size(), 0.0, x.time());
        else
            return x;
    }
    if (x.deterministic_ && QuantLib::close_enough(x.constantData_, 0.0))
        return x;
    resumeCalcStats();
    for (Size i = 0; i < x.size(); ++i) {
        if (!f[i])
            x.set(i, 0.0);
    }
    stopCalcStats(x.size());
    return x;
}

applyInverseFilter

RandomVariable applyInverseFilter ( RandomVariable  , const Filter &    )

friend

Definition at line 1087 of file randomvariable.cpp.

                                                                     {
    if (!x.initialised())
        return x;
    QL_REQUIRE(!f.initialised() || f.size() == x.size(), "RandomVariable: applyFitler(x,f): filter size ("
                                                             << f.size() << ") must be equal to x size (" << x.size()
                                                             << ")");
    if (!f.initialised())
        return x;
    if (f.deterministic()) {
        if (f[0])
            return RandomVariable(x.size(), 0.0, x.time());
        else
            return x;
    }
    if (x.deterministic_ && QuantLib::close_enough(x.constantData_, 0.0))
        return x;
    resumeCalcStats();
    for (Size i = 0; i < x.size(); ++i) {
        if (f[i])
            x.set(i, 0.0);
    }
    stopCalcStats(x.size());
    return x;
}

conditionalResult

RandomVariable conditionalResult ( const Filter &  , RandomVariable  , const RandomVariable &    )

friend

Definition at line 872 of file randomvariable.cpp.

                                                                                             {
    if (!f.initialised() || !x.initialised() || !y.initialised())
        return RandomVariable();
    QL_REQUIRE(f.size() == x.size(),
               "conditionalResult(f,x,y): f size (" << f.size() << ") must match x size (" << x.size() << ")");
    QL_REQUIRE(f.size() == y.size(),
               "conditionalResult(f,x,y): f size (" << f.size() << ") must match y size (" << y.size() << ")");
    x.checkTimeConsistencyAndUpdate(y.time());
    if (f.deterministic())
        return f.at(0) ? x : y;
    resumeCalcStats();
    x.expand();
    for (Size i = 0; i < f.size(); ++i) {
        if (!f[i])
            x.set(i, y[i]);
    }
    stopCalcStats(f.size());
    return x;
}

indicatorEq

RandomVariable indicatorEq ( RandomVariable  , const RandomVariable &  , const Real  trueVal, const Real  falseVal  )

friend

Definition at line 892 of file randomvariable.cpp.

                                                                                                               {
    if (!x.initialised() || !y.initialised())
        return RandomVariable();
    QL_REQUIRE(x.size() == y.size(), "RandomVariable: indicatorEq(x,y): x size ("
                                         << x.size() << ") must be equal to y size (" << y.size() << ")");
    x.checkTimeConsistencyAndUpdate(y.time());
    if (!y.deterministic_)
        x.expand();
    if (x.deterministic()) {
        x.constantData_ = QuantLib::close_enough(x.constantData_, y.constantData_) ? trueVal : falseVal;
    } else {
        resumeCalcStats();
        for (Size i = 0; i < x.n_; ++i) {
            x.data_[i] = QuantLib::close_enough(x.data_[i], y[i]) ? trueVal : falseVal;
        }
        stopCalcStats(x.n_);
    }
    return x;
}

indicatorGt

RandomVariable indicatorGt ( RandomVariable  , const RandomVariable &  , const Real  trueVal, const Real  falseVal, const Real  eps  )

friend

Definition at line 912 of file randomvariable.cpp.

                                           {
    if (!x.initialised() || !y.initialised())
        return RandomVariable();
    QL_REQUIRE(x.size() == y.size(), "RandomVariable: indicatorEq(x,y): x size ("
                                         << x.size() << ") must be equal to y size (" << y.size() << ")");
    x.checkTimeConsistencyAndUpdate(y.time());
    if (!y.deterministic_)
        x.expand();
    if (eps != 0.0) {
        Real delta = getDelta(x - y, eps);
        if (!QuantLib::close_enough(delta, 0.0)) {
            // logistic function
            x.expand();
            Real delta = getDelta(x - y, eps);
            resumeCalcStats();
            for (Size i = 0; i < x.n_; ++i) {
                x.data_[i] = falseVal + (trueVal - falseVal) * 1.0 / (1.0 + std::exp(-x.data_[i] / delta));
            }
            stopCalcStats(x.n_);
            return x;
        }
    }
    // eps == 0.0 or delta == 0.0
    if (x.deterministic()) {
        x.constantData_ =
            (x.constantData_ > y.constantData_ && !QuantLib::close_enough(x.constantData_, y.constantData_)) ? trueVal
                                                                                                             : falseVal;
    } else {
        resumeCalcStats();
        for (Size i = 0; i < x.n_; ++i) {
            x.data_[i] = (x.data_[i] > y[i] && !QuantLib::close_enough(x.data_[i], y[i])) ? trueVal : falseVal;
        }
        stopCalcStats(x.n_);
    }
    return x;
}

indicatorGeq

RandomVariable indicatorGeq ( RandomVariable  , const RandomVariable &  , const Real  trueVal, const Real  falseVal, const Real  eps  )

friend

Definition at line 950 of file randomvariable.cpp.

                                            {
    if (!x.initialised() || !y.initialised())
        return RandomVariable();
    QL_REQUIRE(x.size() == y.size(), "RandomVariable: indicatorEq(x,y): x size ("
                                         << x.size() << ") must be equal to y size (" << y.size() << ")");
    x.checkTimeConsistencyAndUpdate(y.time());
    if (!y.deterministic_)
        x.expand();
    if (eps != 0.0) {
        Real delta = getDelta(x - y, eps);
        if (!QuantLib::close_enough(delta, 0.0)) {
            // logistic function
            x.expand();
            Real delta = getDelta(x - y, eps);
            resumeCalcStats();
            for (Size i = 0; i < x.n_; ++i) {
                x.data_[i] = falseVal + (trueVal - falseVal) * 1.0 / (1.0 + std::exp(-x.data_[i] / delta));
            }
            stopCalcStats(x.n_);
            return x;
        }
    }
    // eps == 0.0 or delta == 0.0
    if (x.deterministic()) {
        x.constantData_ =
            (x.constantData_ > y.constantData_ || QuantLib::close_enough(x.constantData_, y.constantData_)) ? trueVal
                                                                                                            : falseVal;
    } else {
        resumeCalcStats();
        for (Size i = 0; i < x.n_; ++i) {
            x.data_[i] = (x.data_[i] > y[i] || QuantLib::close_enough(x.data_[i], y[i])) ? trueVal : falseVal;
        }
        stopCalcStats(x.n_);
    }
    return x;
}

Member Data Documentation

deleter

std::function< void(RandomVariable &)> deleter

static

Initial value:

=
    std::function<void(RandomVariable&)>([](RandomVariable& x) { x.clear(); })

Definition at line 227 of file randomvariable.hpp.

n_

Size n_

private

Definition at line 246 of file randomvariable.hpp.

constantData_

double constantData_

private

Definition at line 247 of file randomvariable.hpp.

data_

double* data_

private

Definition at line 248 of file randomvariable.hpp.

deterministic_

bool deterministic_

private

Definition at line 249 of file randomvariable.hpp.

time_

Real time_

private

Definition at line 250 of file randomvariable.hpp.