void Programme::addVariable(Variable& var) {
	if(hasVar(variables, var.getNom())) {
		throw "La variable \""+var.getNom()+"\" a déjà été instanciée dans le programme \""+nom+"\".";
	}
	else if(hasVar(arguments, var.getNom())) {
		throw "La variable \""+var.getNom()+"\" a déjà été instanciée dans le programme \""+nom+"\" en tant qu'argument.";
	}
	else {
		variables.push_back(var);
	}
}

ZCsl::Variable* ZCsl::Block::findVar(const ZString& aVarName, ZBoolean aFail)
{
   ZFUNCTRACE_DEVELOP("ZCsl::Block::findVar(const ZString& aVarName, ZBoolean aFail)");
   Variable* v = iVars;
   while (v) {
      if (v->match(aVarName)) return v;
      v = v->iPrev;
   } // while
   if (aFail) iParent->throwExcept(msgVarNotFound, aVarName);
   return v;
} // findVar

void Variables::removeGlobal(const Symbol& _key, int _iLevel)
{
    Variable* pVar = getOrCreate(_key);
    if (pVar->isGlobal())
    {
        pVar->setGlobal(false);
        pVar->setGlobalValue(NULL);
    }

    remove(pVar, _iLevel);
}

void MmaSink::put(const Variable& x) {
#ifdef DEBUG_MMASINK
  GBStream << "sink:variable " << this << x.cstring() << '\n';
#endif
  MLPutFunction(d_mlink,"ToExpression",1L);
  MLPutString(d_mlink,x.cstring());
#ifdef DEBUG_MMASINK
  checkforerror();
#endif
  ++d_count;
};

      std::string process_impl(Variable const & e, bool /*use_parenthesis*/, rt_latex_translator<InterfaceType> const & /*translator*/) const
      {
        std::stringstream ss;

        std::map<id_type, std::string>::const_iterator it = variable_strings_.find(e.id());
        if (it != variable_strings_.end())
          ss << it->second;
        else
          ss << " x_{" << e.id() << "} ";

        return ss.str();
      }

Variable Array::getMember(const Variable &id) {
	if (id.isNumber()) {
		std::list<Variable>::iterator iter = _values.begin();
		std::advance(iter, static_cast<size_t>(id.asNumber()));
		return *iter;
	}

	if (id.isString() && id.asString() == "length")
		return Variable((unsigned long)_values.size());

	return Object::getMember(id);
}

static bool isRecordTypeWithoutSideEffects(const Variable& var)
{
    // a type that has no side effects (no constructors and no members with constructors)
    /** @todo false negative: check base class for side effects */
    /** @todo false negative: check constructors for side effects */
    if (var.type() && var.type()->numConstructors == 0 &&
        (var.type()->varlist.empty() || var.type()->needInitialization == Scope::True) &&
        var.type()->derivedFrom.empty())
        return true;

    return false;
}

/// <summary>
/// The example shows
/// - how to load a pretrained model and evaluate several nodes by combining their outputs
/// Note: The example uses the model trained by <CNTK>/Examples/Image/Classification/ResNet/Python/TrainResNet_CIFAR10.py
/// Please see README.md in <CNTK>/Examples/Image/Classification/ResNet about how to train the model.
/// The parameter 'modelFilePath' specifies the path to the model.
/// </summary>
void EvaluateCombinedOutputs(const wchar_t* modelFilePath, const DeviceDescriptor& device)
{
    printf("\n===== Evaluate combined outputs =====\n");

    // Load the model.
    FunctionPtr modelFunc = Function::Load(modelFilePath, device);

    // Get node of interest
    std::wstring intermediateLayerName = L"final_avg_pooling";
    FunctionPtr interLayerPrimitiveFunc = modelFunc->FindByName(intermediateLayerName);

    Variable poolingOutput = interLayerPrimitiveFunc->Output();

    // Create a function which combine outputs from the node "final_avg_polling" and the final layer of the model.
    FunctionPtr evalFunc = Combine( { modelFunc->Output(), poolingOutput });
    Variable inputVar = evalFunc->Arguments()[0];

    // Prepare input data.
    // For evaluating an image, you first need to perform some image preprocessing to make sure that the input image has the correct size and layout
    // that match the model inputs.
    // Please note that the model used by this example expects the CHW image layout.
    // inputVar.Shape[0] is image width, inputVar.Shape[1] is image height, and inputVar.Shape[2] is channels.
    // For simplicity and avoiding external dependencies, we skip the preprocessing step here, and just use some artificially created data as input.
    std::vector<float> inputData(inputVar.Shape().TotalSize());
    for (size_t i = 0; i < inputData.size(); ++i)
    {
        inputData[i] = static_cast<float>(i % 255);
    }

    // Create input value and input data map
    ValuePtr inputVal = Value::CreateBatch(inputVar.Shape(), inputData, device);
    std::unordered_map<Variable, ValuePtr> inputDataMap = { { inputVar, inputVal } };

    // Create output data map. Using null as Value to indicate using system allocated memory.
    // Alternatively, create a Value object and add it to the data map.
    Variable modelOutput = evalFunc->Outputs()[0];
    Variable interLayerOutput = evalFunc->Outputs()[1];

    std::unordered_map<Variable, ValuePtr> outputDataMap = { { modelOutput, nullptr }, { interLayerOutput, nullptr } };

    // Start evaluation on the device
    evalFunc->Evaluate(inputDataMap, outputDataMap, device);

    // Get evaluate result as dense outputs
    for(auto & outputVariableValuePair : outputDataMap)
    {
        auto variable = outputVariableValuePair.first;
        auto value = outputVariableValuePair.second;
        std::vector<std::vector<float>> outputData;
        value->CopyVariableValueTo(variable, outputData);
        PrintOutput<float>(variable.Shape().TotalSize(), outputData);
    }
}

Variable * VariableScript::_build_value(LR_Node *node) {
    Variable *ret = 0;
    switch (node->productionId()) {
        case internal::PROD_value_0:
            ret = Variable_null::instance();
            ret->grab();
            break;
            
        case internal::PROD_value_1:
            ret = vnnew Variable_bool(true);
            break;
            
        case internal::PROD_value_2:
            ret = vnnew Variable_bool(false);
            break;
            
        case internal::PROD_value_3:
            ret = vnnew Variable_int32(node->child(0)->token()->int32);
            break;
            
        case internal::PROD_value_4:
            ret = vnnew Variable_int64(node->child(0)->token()->int64);
            break;
            
        case internal::PROD_value_5:
            ret = vnnew Variable_float32(node->child(0)->token()->float32);
            break;
            
        case internal::PROD_value_6:
            ret = vnnew Variable_float64(node->child(0)->token()->float64);
            break;
            
        case internal::PROD_value_7:
            ret = vnnew Variable_string(node->child(0)->token()->text);
            break;
            
        case internal::PROD_value_8:
            ret = _build_reference(node->child(0));
            break;
            
        case internal::PROD_value_9:
            ret = _build_array(node->child(0));
            break;
            
        case internal::PROD_value_10: {
            Variable_object *object = vnnew Variable_object();
            _build_object(node->child(0), object);
            ret = object;
            break;
        }
    }
    return ret;
}

bool VariablesInfo::SetVarValue(string varName, float varValue) {
	Variable* var = NULL;
	unsigned i;
	for (i = 0; i < mVariables.size() && var == NULL; i++) {
		if (mVariables[i]->GetVarName() == varName) var = mVariables[i];
	}
	if (var != NULL) {
		var->SetVarValue(varValue);
		return true;
	}
	return false;
}

Variable::commandPrompResults Variable::CompareWith(const Variable &aVariable) const {
	Variable::Type type = aVariable.getType();
	if (type == FLOAT || type == FLOAT) {
		return CompareWithFloat(aVariable.getFloat());
	} else if (type == INT && type == INT) {
		return CompareWithInt(aVariable.getInteger());
	} else if (type == STRING || type == STRING) {
		return CompareWithString(aVariable.getString());
	}

	return UNDEFCMP;
}

//-----------------------------------------------------------------------------
// Returns colour data from the named variable.
//-----------------------------------------------------------------------------
D3DCOLORVALUE *Script::GetColourData( char *variable )
{
	m_variables->Iterate( true );
	while( m_variables->Iterate() != NULL )
	{
		Variable* pVar = m_variables->GetCurrent();
		if( strcmp( pVar->GetName(), variable ) == 0 )
			return (D3DCOLORVALUE*)m_variables->GetCurrent()->GetData();
	}

	return NULL;
}

bool Registry::AddVariableToCurrentImportList(Variable* import_var)
{
  Module* submod = CurrentModule()->GetVariable(m_currentImportedModule)->GetModule();
  Variable* var = submod->GetNextExportVariable();
  if (var == NULL) {
    string error = "Unable to add variable '" + import_var->GetNameDelimitedBy(GetCC()) + "' when creating an instance of the module '" + submod->GetModuleName() + "' because this module is defined to have only " + SizeTToString(submod->GetNumExportVariables()) + " variable(s) definable by default in its construction.";
    SetError(error);
    return true;
  }
  var->Synchronize(import_var);
  return false;
}

void IISource::get(Variable& x) {
  int type = getType();
  if(type==GBInputNumbers::s_IOSYMBOL) {
    symbolGB y;
    ((ISource *)this)->get(y);
    x.assign(y.value().chars());
  } else if(type==GBInputNumbers::s_IOFUNCTION) {
    StringAccumulator acc; 
    getAnything(acc);
    x.assign(acc.chars());
  } else DBG();
};

bool ReactantList::SetComponentFormulasTo(Formula form)
{
  for (size_t component=0; component<m_components.size(); component++) {
    Module* module = g_registry.GetModule(m_module);
    assert(module != NULL);
    Variable* var = module->GetVariable(m_components[component].second);
    if (var != NULL) {
      if (var->SetFormula(&form)) return true;
    }
  }
  return false;
}

void Variable::operator=(const Variable &aVariable) {
	Variable::Type type = aVariable.getType();

	if (type == INT) {
		set(aVariable.getInteger());
	} else if (type == FLOAT) {
		set(aVariable.getFloat());
	} else if (type == STRING) {
		set(aVariable.getString());
	} else {
		clear();
	}
}

Variable*  Execution::exUnaryExpression(TreeNode* t){
    this->testNode(t, UnaryExpression, true);
    TreeNode* c = t->child;
    if (c->sibling != NULL){
        string op = exUnaryOperator(c);
        Variable* tmp = UnaryExpression(c->sibling);
        Variable* res = Expression::opUnary(op, tmp);
        tmp->release();
        return res;
    } else{
        return PostfixExpression(c);
    }
}

void
BuildItem::addToVariable( const std::string &name, const Variable &val )
{
	auto i = myVariables.find( name );
	if ( i != myVariables.end() )
		i->second.moveToEnd( val.values() );
	else
	{
		auto ni = myVariables.emplace( std::make_pair( name, Variable( val ) ) );
		if ( val.useToolFlagTransform() )
			ni.first->second.setToolTag( val.getToolTag() );
	}
}

FunctionPtr FullyConnectedDNNLayer(Variable input, size_t outputDim, const DeviceDescriptor& device, const std::function<FunctionPtr(const FunctionPtr&)>& nonLinearity)
{
    assert(input.Shape().NumAxes() == 1);
    size_t inputDim = input.Shape()[0];

    auto timesParam = Parameter(NDArrayView::RandomUniform<float>({ outputDim, inputDim }, -0.5, 0.5, 1, device));
    auto timesFunction = Times(timesParam, input);

    auto plusParam = Parameter({ outputDim }, 0.0f, device);
    auto plusFunction = Plus(plusParam, timesFunction);

    return nonLinearity(plusFunction);
}

void AntimonyEvent::Convert(Variable* converted, Variable* cf)
{
  m_trigger.Convert(converted, cf);
  m_delay.Convert(converted, cf);
  m_priority.Convert(converted, cf);
  for (size_t fr=0; fr<m_formresults.size(); fr++) {
    Variable* asntvar = g_registry.GetModule(m_module)->GetVariable(m_varresults[fr]);
    if (converted->GetSameVariable() == asntvar->GetSameVariable()) {
      m_formresults[fr].AddConversionFactor(cf);
    }
    m_formresults[fr].Convert(converted, cf);
  }
}