ComputationGraph Class Reference

#include <qle/ad/computationgraph.hpp>

Collaboration diagram for ComputationGraph:

Public Types
enum class	VarDoesntExist { Nan , Create , Throw }

Public Member Functions
void	clear ()
std::size_t	size () const
std::size_t	insert (const std::string &label=std::string())
std::size_t	insert (const std::vector< std::size_t > &predecessors, const std::size_t opId, const std::string &label=std::string())
const std::vector< std::size_t > &	predecessors (const std::size_t node) const
std::size_t	opId (const std::size_t node) const
std::size_t	maxNodeRequiringArg (const std::size_t node) const
std::size_t	constant (const double c)
const std::map< double, std::size_t > &	constants () const
bool	isConstant (const std::size_t node) const
double	constantValue (const std::size_t node) const
std::size_t	variable (const std::string &name, const VarDoesntExist v=VarDoesntExist::Throw)
const std::map< std::string, std::size_t > &	variables () const
void	setVariable (const std::string &name, const std::size_t node)
void	enableLabels (const bool b=true)
const std::map< std::size_t, std::set< std::string > > &	labels () const
void	startRedBlock ()
void	endRedBlock ()
std::size_t	redBlockId (const std::size_t node) const
const std::vector< std::pair< std::size_t, std::size_t > > &	redBlockRanges () const
const std::set< std::size_t > &	redBlockDependencies () const

Static Public Attributes
static std::size_t	nan = std::numeric_limits<std::size_t>::max()

Private Attributes
std::vector< std::vector< std::size_t > >	predecessors_
std::vector< std::size_t >	opId_
std::vector< bool >	isConstant_
std::vector< double >	constantValue_
std::vector< std::size_t >	maxNodeRequiringArg_
std::vector< std::size_t >	redBlockId_
std::map< double, std::size_t >	constants_
std::map< std::string, std::size_t >	variables_
std::map< std::string, std::size_t >	variableVersion_
bool	enableLabels_ = false
std::map< std::size_t, std::set< std::string > >	labels_
std::size_t	currentRedBlockId_ = 0
std::size_t	nextRedBlockId_ = 0
std::vector< std::pair< std::size_t, std::size_t > >	redBlockRange_
std::set< std::size_t >	redBlockDependencies_

Detailed Description

• opId = 0 should refer to "no operation"

Definition at line 35 of file computationgraph.hpp.

Member Enumeration Documentation

VarDoesntExist

enum class VarDoesntExist

strong

Enumerator
Nan
Create
Throw

Definition at line 37 of file computationgraph.hpp.

{ Nan, Create, Throw };

Member Function Documentation

clear()

void clear

(

)

Definition at line 32 of file computationgraph.cpp.

                             {
    predecessors_.clear();
    opId_.clear();
    maxNodeRequiringArg_.clear();
    redBlockId_.clear();
    isConstant_.clear();
    constantValue_.clear();
    constants_.clear();
    variables_.clear();
    variableVersion_.clear();
    labels_.clear();
}

size()

std::size_t size

(

)

const

Definition at line 45 of file computationgraph.cpp.

{ return predecessors_.size(); }

Here is the caller graph for this function:

insert() [1/2]

std::size_t insert

(

const std::string &

label = std::string()

)

Definition at line 47 of file computationgraph.cpp.

                                                         {
    std::size_t node = predecessors_.size();
    predecessors_.push_back(std::vector<std::size_t>());
    opId_.push_back(0);
    maxNodeRequiringArg_.push_back(0);
    redBlockId_.push_back(currentRedBlockId_);
    isConstant_.push_back(false);
    constantValue_.push_back(0.0);
    if (enableLabels_ && !label.empty())
        labels_[node].insert(label);
    return node;
}

Here is the caller graph for this function:

insert() [2/2]

std::size_t insert	(	const std::vector< std::size_t > &	predecessors,
		const std::size_t	opId,
		const std::string &	label = std::string()
	)

Definition at line 60 of file computationgraph.cpp.

                                                             {
    std::size_t node = predecessors_.size();
    predecessors_.push_back(predecessors);
    opId_.push_back(opId);
    for (auto const& p : predecessors) {
        maxNodeRequiringArg_[p] = node;
    }
    maxNodeRequiringArg_.push_back(0);
    redBlockId_.push_back(currentRedBlockId_);
    if (currentRedBlockId_ != 0) {
        for (auto const& p : predecessors) {
            if (redBlockId(p) != currentRedBlockId_) {
                redBlockDependencies_.insert(p);
            }
        }
    }
    isConstant_.push_back(false);
    constantValue_.push_back(0.0);
    if (enableLabels_ && !label.empty())
        labels_[node].insert(label);
    return node;
}

Here is the call graph for this function:

predecessors()

const std::vector< std::size_t > & predecessors

(

const std::size_t

node

)

const

Definition at line 84 of file computationgraph.cpp.

                                                                                     {
    return predecessors_[node];
}

Here is the caller graph for this function:

opId()

std::size_t opId

(

const std::size_t

node

)

const

Definition at line 88 of file computationgraph.cpp.

{ return opId_[node]; }

Here is the caller graph for this function:

maxNodeRequiringArg()

std::size_t maxNodeRequiringArg

(

const std::size_t

node

)

const

Definition at line 90 of file computationgraph.cpp.

{ return maxNodeRequiringArg_[node]; }

constant()

std::size_t constant

(

const double

c

)

Definition at line 92 of file computationgraph.cpp.

                                                   {
    auto c = constants_.find(x);
    if (c != constants_.end())
        return c->second;
    else {
        std::size_t node = predecessors_.size();
        constants_.insert(std::make_pair(x, node));
        predecessors_.push_back(std::vector<std::size_t>());
        opId_.push_back(0);
        maxNodeRequiringArg_.push_back(0);
        redBlockId_.push_back(currentRedBlockId_);
        isConstant_.push_back(true);
        constantValue_.push_back(x);
        if (enableLabels_)
            labels_[node].insert(std::to_string(x));
        return node;
    }
}

Here is the caller graph for this function:

constants()

const std::map< double, std::size_t > & constants

(

)

const

Definition at line 111 of file computationgraph.cpp.

{ return constants_; }

isConstant()

bool isConstant

(

const std::size_t

node

)

const

Definition at line 183 of file computationgraph.cpp.

{ return isConstant_[node]; }

Here is the caller graph for this function:

constantValue()

double constantValue

(

const std::size_t

node

)

const

Definition at line 185 of file computationgraph.cpp.

{ return constantValue_[node]; }

Here is the caller graph for this function:

variable()

std::size_t variable	(	const std::string &	name,
		const VarDoesntExist	v = VarDoesntExist::Throw
	)

Definition at line 113 of file computationgraph.cpp.

                                                                                  {
    auto c = variables_.find(name);
    if (c != variables_.end())
        return c->second;
    else if (v == VarDoesntExist::Create) {
        std::size_t node = predecessors_.size();
        variables_.insert(std::make_pair(name, node));
        variableVersion_[name] = 0;
        if (enableLabels_)
            labels_[node].insert(name + "(v" + std::to_string(++variableVersion_[name]) + ")");
        predecessors_.push_back(std::vector<std::size_t>());
        opId_.push_back(0);
        maxNodeRequiringArg_.push_back(0);
        redBlockId_.push_back(currentRedBlockId_);
        isConstant_.push_back(false);
        constantValue_.push_back(0.0);
        return node;
    } else if (v == VarDoesntExist::Nan) {
        return nan;
    } else if (v == VarDoesntExist::Throw) {
        QL_FAIL("ComputationGraph::variable(" << name << ") not found.");
    } else {
        QL_FAIL("ComputationGraph::variable(): internal error, VarDoesntExist enum '" << static_cast<int>(v)
                                                                                      << "' not covered.");
    }
}

Here is the caller graph for this function:

variables()

const std::map< std::string, std::size_t > & variables

(

)

const

Definition at line 140 of file computationgraph.cpp.

{ return variables_; }

setVariable()

void setVariable	(	const std::string &	name,
		const std::size_t	node
	)

Definition at line 142 of file computationgraph.cpp.

                                                                              {
    auto v = variables_.find(name);
    if (v != variables_.end()) {
        if (v->second != node) {
            if (enableLabels_)
                labels_[node].insert(name + "(v" + std::to_string(++variableVersion_[name]) + ")");
            v->second = node;
        }
    } else {
        variableVersion_[name] = 0;
        if (enableLabels_)
            labels_[node].insert(name + "(v" + std::to_string(++variableVersion_[name]) + ")");
        variables_[name] = node;
    }
}

enableLabels()

void enableLabels

(

const bool

b = true

)

Definition at line 158 of file computationgraph.cpp.

{ enableLabels_ = b; }

labels()

const std::map< std::size_t, std::set< std::string > > & labels

(

)

const

Definition at line 160 of file computationgraph.cpp.

{ return labels_; }

startRedBlock()

void startRedBlock

(

)

Definition at line 162 of file computationgraph.cpp.

                                     {
    currentRedBlockId_ = ++nextRedBlockId_;
    if (!redBlockRange_.empty())
        redBlockRange_.back().second = size();
    redBlockRange_.push_back(std::make_pair(size(), nan));
}

Here is the call graph for this function:

endRedBlock()

void endRedBlock

(

)

Definition at line 169 of file computationgraph.cpp.

                                   {
    QL_REQUIRE(currentRedBlockId_ > 0, "ComputationGraph::endRedBlock(): not in an active red block.");
    currentRedBlockId_ = 0;
    redBlockRange_.back().second = size();
}

Here is the call graph for this function:

redBlockId()

std::size_t redBlockId

(

const std::size_t

node

)

const

Definition at line 181 of file computationgraph.cpp.

{ return redBlockId_[node]; }

Here is the caller graph for this function:

redBlockRanges()

const std::vector< std::pair< std::size_t, std::size_t > > & redBlockRanges

(

)

const

Definition at line 175 of file computationgraph.cpp.

                                                                                       {
    return redBlockRange_;
}

redBlockDependencies()

const std::set< std::size_t > & redBlockDependencies

(

)

const

Definition at line 179 of file computationgraph.cpp.

{ return redBlockDependencies_; }

Member Data Documentation

nan

std::size_t nan = std::numeric_limits<std::size_t>::max()

static

Definition at line 38 of file computationgraph.hpp.

predecessors_

std::vector<std::vector<std::size_t> > predecessors_

private

Definition at line 70 of file computationgraph.hpp.

opId_

std::vector<std::size_t> opId_

private

Definition at line 71 of file computationgraph.hpp.

isConstant_

std::vector<bool> isConstant_

private

Definition at line 72 of file computationgraph.hpp.

constantValue_

std::vector<double> constantValue_

private

Definition at line 73 of file computationgraph.hpp.

maxNodeRequiringArg_

std::vector<std::size_t> maxNodeRequiringArg_

private

Definition at line 74 of file computationgraph.hpp.

redBlockId_

std::vector<std::size_t> redBlockId_

private

Definition at line 75 of file computationgraph.hpp.

constants_

std::map<double, std::size_t> constants_

private

Definition at line 77 of file computationgraph.hpp.

variables_

std::map<std::string, std::size_t> variables_

private

Definition at line 79 of file computationgraph.hpp.

variableVersion_

std::map<std::string, std::size_t> variableVersion_

private

Definition at line 80 of file computationgraph.hpp.

enableLabels_

bool enableLabels_ = false

private

Definition at line 82 of file computationgraph.hpp.

labels_

std::map<std::size_t, std::set<std::string> > labels_

private

Definition at line 83 of file computationgraph.hpp.

currentRedBlockId_

std::size_t currentRedBlockId_ = 0

private

Definition at line 85 of file computationgraph.hpp.

nextRedBlockId_

std::size_t nextRedBlockId_ = 0

private

Definition at line 86 of file computationgraph.hpp.

redBlockRange_

std::vector<std::pair<std::size_t, std::size_t> > redBlockRange_

private

Definition at line 87 of file computationgraph.hpp.

redBlockDependencies_

std::set<std::size_t> redBlockDependencies_

private

Definition at line 88 of file computationgraph.hpp.