MatrixPtr GenerateClusteredData::operator()() {
auto matrix = std::make_shared<Matrix>();
matrix->reserve(nbrInds);
Variables variables;
for (size_t var = 0; var < nbrClusters * clustSize; ++var) {
variables ^= Variable( boost::lexical_cast<std::string>(var),
plIntegerType(0, cardinality-1) );
}
Clustering clustering; clustering.reserve(nbrClusters);
for ( size_t clust = 0; clust < nbrClusters; ++clust ) {
Cluster cluster;
for ( size_t item = 0; item < clustSize; ++item ) {
cluster.push_back( clust*clustSize + item );
}
clustering.push_back( cluster );
}
plJointDistribution jointDist = createClusteringJointDist( variables, clustering);
plValues values( variables );
// std::cout << jointDist << std::endl << jointDist.get_computable_object_list() << std::endl;
for (size_t ind = 0; ind < nbrInds; ++ind) {
jointDist.draw(values);
std::vector<int> row(variables.size());
for (size_t var = 0; var < variables.size(); ++var) {
row[var] = values[variables[var]];
}
matrix->push_back(row);
}
//std::cout << jointDist << std::endl;
return Transpose(*matrix);
}
Variables Stack::getVariables() const {
Variables vars;
for (int i = 1; i <= getSize(); ++i) {
vars.push_back(getVariableAt(i));
}
return vars;
}
void
madara::knowledge::containers::NativeDoubleVector::set_name (
const std::string & var_name,
Variables & knowledge, int size)
{
if (context_ != knowledge.get_context () || name_ != var_name)
{
context_ = knowledge.get_context ();
ContextGuard context_guard (*context_);
MADARA_GUARD_TYPE guard (mutex_);
madara_logger_ptr_log (logger::global_logger.get (),
logger::LOG_MAJOR,
"NativeDoubleVector::set_name: setting name to %s\n",
var_name.c_str ());
name_ = var_name;
vector_ = knowledge.get_ref (var_name, settings_);
if (size > 0)
resize (size_t (size));
}
}
/*
* Class: ai_madara_knowledge_Variables
* Method: jni_compile
* Signature: (JLjava/lang/String;)J
*/
jlong JNICALL Java_ai_madara_knowledge_Variables_jni_1compile(
JNIEnv* env, jobject, jlong cptr, jstring expression)
{
const char* nativeExpression = env->GetStringUTFChars(expression, 0);
Variables* vars = (Variables*)cptr;
CompiledExpression* result(0);
if (vars)
{
result = new CompiledExpression(vars->compile(nativeExpression));
env->ReleaseStringUTFChars(expression, nativeExpression);
}
else
{
// user has tried to use a deleted object. Clean up and throw
madara::utility::java::throw_dead_obj_exception(env,
"Variables::compile: "
"Variables objects are released already");
}
return (jlong)result;
}
Variables FunctionRef::call(const Variable &v1, const Variable &v2, const Variable &v3) const {
Variables params;
params.push_back(v1);
params.push_back(v2);
params.push_back(v3);
return call(params);
}
void VariablesTest::test_count_targets_number(void)
{
message += "test_count_targets_number\n";
Variables v;
assert_true(v.count_targets_number() == 0, LOG);
}
void VariablesTest::test_get_variables_number(void)
{
message += "test_get_variables_number\n";
Variables v;
assert_true(v.get_variables_number() == 0, LOG);
}
Aurora::Lua::Variables Aurora::Lua::Stack::getVariablesFromTop(int count) const {
Variables vars;
const int start = std::max(0, getSize() - count) + 1;
for (int i = start; i <= getSize(); ++i) {
vars.push_back(getVariableAt(i));
}
return vars;
}
int InterpreterDBG::nextCmd(int line, Variables& v, list<pair<string, int> >& stk) {
sendStackInfo(stk);
sendVariables(v.getGlobals(), stk, true);
sendVariables(v.getLocals(), stk, false);
return receiveCmd();
}
void CheckUnusedVar::checkFunctionVariableUsage()
{
if (!_settings->isEnabled("style"))
return;
// Parse all executing scopes..
const SymbolDatabase *symbolDatabase = _tokenizer->getSymbolDatabase();
for (std::list<Scope>::const_iterator scope = symbolDatabase->scopeList.begin(); scope != symbolDatabase->scopeList.end(); ++scope) {
// only check functions
if (scope->type != Scope::eFunction)
continue;
// varId, usage {read, write, modified}
Variables variables;
checkFunctionVariableUsage_iterateScopes(&*scope, variables);
// Check usage of all variables in the current scope..
for (Variables::VariableMap::const_iterator it = variables.varUsage().begin(); it != variables.varUsage().end(); ++it) {
const Variables::VariableUsage &usage = it->second;
const std::string &varname = usage._name->str();
// variable has been marked as unused so ignore it
if (usage._name->isUnused())
continue;
// skip things that are only partially implemented to prevent false positives
if (usage._type == Variables::pointerPointer ||
usage._type == Variables::pointerArray ||
usage._type == Variables::referenceArray)
continue;
// variable has had memory allocated for it, but hasn't done
// anything with that memory other than, perhaps, freeing it
if (usage.unused() && !usage._modified && usage._allocateMemory)
allocatedButUnusedVariableError(usage._name, varname);
// variable has not been written, read, or modified
else if (usage.unused() && !usage._modified)
unusedVariableError(usage._name, varname);
// variable has not been written but has been modified
else if (usage._modified && !usage._write && !usage._allocateMemory)
unassignedVariableError(usage._name, varname);
// variable has been written but not read
else if (!usage._read && !usage._modified)
unreadVariableError(usage._name, varname);
// variable has been read but not written
else if (!usage._write && !usage._allocateMemory)
unassignedVariableError(usage._name, varname);
}
}
}
void VariablesTest::test_arrange_targets_indices(void)
{
message += "test_arrange_targets_indices\n";
Variables v;
Vector<size_t> targets_indices = v.arrange_targets_indices();
assert_true(targets_indices.size() == 0, LOG);
}
void VariablesTest::test_arrange_names(void)
{
message += "test_get_names\n";
Variables v;
Vector<std::string> names = v.arrange_names();
assert_true(names.size() == 0, LOG);
}
const char* build_get_variable(const char* name)
{
Variables::iterator i = g_build_variables.find(name);
if(i != g_build_variables.end())
{
return (*i).second.c_str();
}
globalErrorStream() << "undefined build variable: " << makeQuoted(name) << "\n";
return "";
}
void VariablesTest::test_arrange_units(void)
{
message += "test_arrange_units\n";
Variables v;
Vector<std::string> units = v.arrange_units();
assert_true(units.size() == 0, LOG);
}
void VariablesTest::test_arrange_descriptions(void)
{
message += "test_arrange_descriptions\n";
Variables v;
Vector<std::string> descriptions = v.arrange_descriptions();
assert_true(descriptions.size() == 0, LOG);
}
static void filterFields (const StringSet &avoid, Variables &fields) {
for (int i = 0; i < fields.length (); i++) {
const VariableDef &cur = fields.at (i);
if (avoid.contains (cur.type)) {
fields.remove (i);
i--;
}
}
}
/**
* Applies the required resizes to nodes in the specified axis, rerouting edges
* around the resized nodes.
* @param dim axis
* @param targets the target rectangles (in both axes)
* @param nodes to be moved and/or resized
* @param edges to be rerouted around nodes
* @param resizes ResizeInfo for specific nodes
* @param vs canonical list of variables passed into solver. Note that
* the first nodes.size() variables are used for each corresponding node.
* Note also that new variables for the dummy nodes will be appended to this
* list and will need to be cleaned up later.
* @param cs canonical list of constraints over variables. Note that new
* non-overlap constraints may be appended to the end of this list.
*/
static void resizeAxis(vpsc::Dim dim, const Rectangles& targets,
Nodes& nodes, Edges& edges, RootCluster *clusters, ResizeMap& resizes,
Variables& vs, Constraints& cs)
{
COLA_ASSERT(vs.size()>=nodes.size());
// - create copy tn of topologyNodes with resize rects replaced with
// three nodes: one for the lhs of rect, one for centre and one for rhs.
// lhs node goes at position of replaced node, the others are appended
// to end of tn.
// - set desired positions of each lhs node to be the left side
// of resized rect and symmetric for rhs node, centre node's desired
// pos it at the centre
Nodes tn(nodes.size());
COLA_ASSERT(assertConvexBends(edges));
COLA_ASSERT(assertNoSegmentRectIntersection(nodes,edges));
transform(nodes.begin(),nodes.end(),tn.begin(),
TransformNode(dim, targets,resizes,vs));
feach(resizes, CreateLeftRightDummyNodes(dim,targets,tn,vs));
COLA_ASSERT(tn.size()==nodes.size()+2*resizes.size());
COLA_ASSERT(vs.size()>=tn.size());
// update topologyRoutes with references to resized nodes replaced with
// correct references to lhs/rhs nodes
feach(edges,SubstituteNodes(dim,resizes,tn));
COLA_ASSERT(assertConvexBends(edges));
COLA_ASSERT(assertNoSegmentRectIntersection(tn,edges));
// move nodes and reroute
topology::TopologyConstraints t(dim, tn, edges, clusters, vs, cs);
COLA_ASSERT(checkDesired(dim,tn,targets,resizes));
#ifndef NDEBUG
unsigned loopCtr=0;
#endif
while(t.solve()) { COLA_ASSERT(++loopCtr<1000); }
//COLA_ASSERT(checkFinal(tn,targets,resizes));
// reposition and resize original nodes
feach(nodes,CopyPositions(dim,tn,resizes));
// revert topologyRoutes back to original nodes
feach(edges,RevertNodes(nodes));
COLA_ASSERT(assertConvexBends(edges));
COLA_ASSERT(assertNoSegmentRectIntersection(nodes,edges));
// clean up
feach(tn,DeleteTempNode());
}
void VariablesTest::test_set(void)
{
message += "test_set\n";
Variables v;
// Instances and inputs and target variables
v.set(1);
assert_true(v.count_inputs_number() == 0, LOG);
assert_true(v.count_targets_number() == 0, LOG);
}
void VariablesTest::test_from_XML(void)
{
message += "test_from_XML\n";
Variables v;
// Test
v.set(3);
tinyxml2::XMLDocument* document = v.to_XML();
v.from_XML(*document);
}
void VariablesTest::test_get_display(void)
{
message += "test_get_display\n";
Variables v;
v.set_display(true);
assert_true(v.get_display() == true, LOG);
v.set_display(false);
assert_true(v.get_display() == false, LOG);
}
Variables* Variables::clone() const
{
// owner should always be true
Variables* newVector = new Variables(true);
int i;
Variable* newItem;
for(i=0;i<items.size();i++)
{
newItem = new Variable(*items.at(i));
newVector->addItem(newItem);
}
return newVector;
}
madara::knowledge::containers::NativeDoubleVectorStaged::
NativeDoubleVectorStaged(const std::string& name, Variables& knowledge,
int size, const KnowledgeUpdateSettings& settings)
: context_(knowledge.get_context()), has_changed_(false)
{
madara_logger_ptr_log(logger::global_logger.get(), logger::LOG_MAJOR,
"NativeDoubleVectorStaged::constructor called for %s[%d]\n", name.c_str(),
size);
vector_ = knowledge.get_ref(name, settings);
if (size >= 0)
{
resize(size);
}
}
Real TaylorApproximation::value(const Variables& vars)
{
short bdo = sharedDataRep->buildDataOrder;
if (bdo == 1)
return approxData.anchor_function();
else { // build up approx value from constant and derivative terms
Real approx_val = (bdo & 1) ? approxData.anchor_function() : 0.;
if (bdo & 6) {
const RealVector& x = vars.continuous_variables();
const RealVector& x0 = approxData.anchor_continuous_variables();
const RealVector& grad = approxData.anchor_gradient();
const RealSymMatrix& hess = approxData.anchor_hessian();
size_t num_v = sharedDataRep->numVars;
for (size_t i=0; i<num_v; i++) {
Real dist_i = x[i] - x0[i];
if (bdo & 2) // include gradient terms
approx_val += grad[i] * dist_i;
if (bdo & 4) // include Hessian terms
for (size_t j=0; j<num_v; j++)
approx_val += dist_i * hess(i,j) * (x[j] - x0[j])/2.;
}
}
return approx_val;
}
}
void PostfixExprEvaluator::processToken(Token &token,
std::stack<Token> &operands,
Variables &vars)
{
switch (token.type)
{
case TokenType::TOK_VARIABLE:
token = vars.at(token.value.valueString);
processToken(token, operands, vars);
break;
case TokenType::TOK_LPAREN:
case TokenType::TOK_RPAREN:
break;
case TokenType::TOK_FLOAT:
case TokenType::TOK_INT:
operands.push(token);
break;
case TokenType::TOK_UNARYOP:
processUnaryOp(token, operands);
break;
case TokenType::TOK_BINARYOP:
processBinaryOp(token, operands);
break;
}
}
IncSolver::IncSolver(Variables const &vs, Constraints const &cs)
: m(cs.size()),
cs(cs),
n(vs.size()),
vs(vs),
needsScaling(false)
{
for(unsigned i=0;i<n;++i) {
vs[i]->in.clear();
vs[i]->out.clear();
// Set needsScaling if any variables have a scale other than 1.
needsScaling |= (vs[i]->scale != 1);
}
for(unsigned i=0;i<m;++i) {
Constraint *c=cs[i];
c->left->out.push_back(c);
c->right->in.push_back(c);
c->needsScaling = needsScaling;
}
bs=new Blocks(vs);
#ifdef LIBVPSC_LOGGING
printBlocks();
//COLA_ASSERT(!constraintGraphIsCyclic(n,vs));
#endif
inactive=cs;
for(Constraints::iterator i=inactive.begin();i!=inactive.end();++i) {
(*i)->active=false;
}
}
void VisitArraySubscriptExpr(clang::ArraySubscriptExpr *AS) {
// find array name and size
clang::DeclRefExpr *DR;
if (!(DR = clang::dyn_cast<clang::DeclRefExpr>(
AS->getBase()->IgnoreImpCasts()))) {
printf("Can't handle complex array expressions:\n\t%s\n",
toString(AS));
exit(1);
}
const char *arr = DR->getDecl()->getNameAsString().c_str();
int size = variables.arraySize(arr);
clang::Expr *ind = AS->getIdx();
// Both size and index are literals. No need for abstraction:
if (clang::IntegerLiteral *IL =
clang::dyn_cast<clang::IntegerLiteral>(ind)) {
int val = (int)*IL->getValue().getRawData();
if (val < 0 || val >= size) {
printf("** Index out of bounds error: Array %s, size %d, index "
"%d\n", arr, size, val);
printf("\t%s\n", toString(AS));
error = true;
}
// Size is a literal but the index is an abstract value:
} else if (clang::DeclRefExpr *DR =
clang::dyn_cast<clang::DeclRefExpr>(ind->IgnoreImpCasts())) {
char *varInd = variables.find(
DR->getDecl()->getNameAsString().c_str());
if (!blkApronCtx->isIndexInBound(varInd, size)) {
printf("** Index out of bounds error: Index %s, Array %s, size "
"%d\n", toString(DR), arr, size);
error = true;
}
} else {
printf("Can't handle compound expressions as array indexes:\n\t%s\n",
toString(AS));
exit(1);
}
// else if (clang::ImplicitCastExpr *CE =
// clang::dyn_cast<clang::ImplicitCastExpr>(ind)) {
// Visit(CE);
// char *indVar = variables.getLastVar();
// analysisCtx->addArrayIndex(indVar, size);
// }
// variables.toggleCollectingVars(false);
}
madara::knowledge::containers::FlexMap::FlexMap(const std::string& name,
Variables& knowledge, const KnowledgeUpdateSettings& settings,
const std::string& delimiter)
: BaseContainer(name, settings),
context_(knowledge.get_context()),
delimiter_(delimiter)
{
}
EqualityConstraintSet(Variables vs)
{
for (size_t i = 0; i < vs.size(); ++i)
{
std::map<Variable *, double> varSet;
varSet[vs[i]] = 0;
variableGroups.push_back(varSet);
}
}
void
madara::knowledge::containers::IntegerVector::set_name (
const std::string & var_name,
Variables & knowledge, int size)
{
if (context_ != knowledge.get_context () || name_ != var_name)
{
context_ = knowledge.get_context ();
ContextGuard context_guard (*context_);
MADARA_GUARD_TYPE guard (mutex_);
name_ = var_name;
vector_.clear ();
resize (size);
}
}
void Deconvolution<T>::forward_impl(const Variables &inputs,
const Variables &outputs) {
using namespace ::nbla::eigen;
// Getting variable pointers
const T *y = inputs[0]->get_data_pointer<T>(this->ctx_);
const T *w = inputs[1]->get_data_pointer<T>(this->ctx_);
T *col = col_.cast_data_and_get_pointer<T>(this->ctx_);
T *x = outputs[0]->cast_data_and_get_pointer<T>(this->ctx_);
const T *b;
if (inputs.size() == 3) {
b = inputs[2]->get_data_pointer<T>(this->ctx_);
}
// Sample loop
for (int n = 0; n < outer_size_; ++n) {
// matrix multiplication
const T *y_n = y + n * inner_size_o_;
for (int g = 0; g < group_; ++g) {
ConstMatrixMap<T> mw(w + g * row_w_ * col_w_, row_w_, col_w_);
ConstMatrixMap<T> my(y_n + g * row_y_ * col_y_, row_y_, col_y_);
MatrixMap<T> mcol(col + g * row_col_ * col_col_, row_col_, col_col_);
mcol = mw.transpose() * my;
}
// col2im for w * x
T *x_n = x + n * inner_size_i_;
memset(x_n, 0, sizeof(*x_n) * inner_size_i_);
if (spatial_dims_ == 2) {
col2im<T>(col, channels_i_, spatial_shape_i_.data(), kernel_.data(),
pad_.data(), stride_.data(), dilation_.data(), x_n);
} else {
col2im_nd<T>(col, channels_i_, spatial_dims_, spatial_shape_i_.data(),
kernel_.data(), pad_.data(), stride_.data(),
dilation_.data(), x_n);
}
// adding bias
if (inputs.size() == 3) {
MatrixMap<T> mx(x_n, channels_i_, inner_size_i_ / channels_i_);
mx.colwise() += ConstColVectorMap<T>(b, channels_i_);
}
}
}
