C++ Variables类代码示例

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);

}