CourseMenu::CourseMenu(fw::GameBase& game) : StateBase(game) , courseMenu_({ game.getWindow().getSize().x / 2.f, 90.f }) { std::string coursesText = framework::loadTextFromFile("data/courses.txt"); std::vector<std::string> coursesLines = framework::getLinesFromText(coursesText); for(const auto line : coursesLines) { auto button = std::make_unique<fw::gui::Button>(); button->setText(line); button->setFunction([&] () { // empty action }); courseMenu_.addWidget(std::move(button)); } auto bback = std::make_unique<fw::gui::Button>(); bback->setText("Back"); bback->setFunction([&]() { game_.popState(); }); courseMenu_.addWidget(std::move(bback)); }
void fitDialog::showExpression(int function) { if (categoryBox->currentItem() == 2) { explainBox->setText(myParser::explainFunction(function)); } else if (categoryBox->currentItem() == 1) { explainBox->setText(builtInFunctions[function]); setFunction(boxUseBuiltIn->isChecked()); } else if (categoryBox->currentItem() == 0) { QStringList l = QStringList::split("=", userFunctions[function], true); explainBox->setText(l[1]); setFunction(boxUseBuiltIn->isChecked()); } else if (categoryBox->currentItem() == 3) { if ((int)pluginFunctions.size() > 0) { explainBox->setText(pluginFunctions[function]); setFunction(boxUseBuiltIn->isChecked()); } else explainBox->clear(); } }
int deviceAccelerometerGetInterface(unsigned char commandHeader, DeviceInterfaceMode mode, bool fillDeviceArgumentList) { if (commandHeader == COMMAND_ACCELEROMETER_GET_SAMPLE_COUNT) { if (fillDeviceArgumentList) { setFunction("getSampleCount", 0, 1); setResultUnsignedHex4(0, "Sample count"); } return commandLengthValueForMode(mode, 0, 4); } else if (commandHeader == COMMAND_ACCELEROMETER_GET_SAMPLE_RAW_DATA) { if (fillDeviceArgumentList) { setFunction("Sample Raw Data", 0, 5); setResultUnsignedHex4(0, "X Raw Data"); setResultSeparator(1); setResultUnsignedHex4(2, "Y Raw Data"); setResultSeparator(3); setResultUnsignedHex4(4, "Z Raw Data"); } return commandLengthValueForMode(mode, 0, 14); } else if (commandHeader == COMMAND_ACCELEROMETER_GET_SAMPLE_DATA_MILLIG_G) { if (fillDeviceArgumentList) { setFunction("Sample Data MilliG", 0, 5); setResultUnsignedHex4(0, "X (mG)"); setResultSeparator(1); setResultUnsignedHex4(2, "Y (mG)"); setResultSeparator(3); setResultUnsignedHex4(4, "Z (mG)"); } return commandLengthValueForMode(mode, 0, 14); } // TRESHOLD else if (commandHeader == COMMAND_ACCELEROMETER_GET_THRESHOLD) { if (fillDeviceArgumentList) { setFunction("Get Threshold", 0, 1); setResultUnsignedHex4(0, "Threshold (milli G)"); } return commandLengthValueForMode(mode, 0, 4); } else if (commandHeader == COMMAND_ACCELEROMETER_SET_THRESHOLD) { if (fillDeviceArgumentList) { setFunction("Set Threshold", 1, 0); setArgumentUnsignedHex4(0, "Threshold (milliG)"); } return commandLengthValueForMode(mode, 4, 0); } // DEBUG else if (commandHeader == COMMAND_ACCELEROMETER_DEBUG_CONFIG) { if (fillDeviceArgumentList) { setFunctionNoArgumentAndNoResult("Debug Config"); } return commandLengthValueForMode(mode, 0, 0); } else if (commandHeader == COMMAND_ACCELEROMETER_DEBUG_VALUES) { if (fillDeviceArgumentList) { setFunctionNoArgumentAndNoResult("Debug Values"); } return commandLengthValueForMode(mode, 0, 0); } return DEVICE_HEADER_NOT_HANDLED; }
int deviceTestGetInterface(char commandHeader, DeviceInterfaceMode mode, bool fillDeviceArgumentList) { if (commandHeader == COMMAND_TEST) { if (fillDeviceArgumentList) { setFunction("test", 2, 1); setArgumentUnsignedHex2(0, "a"); setArgumentUnsignedHex2(1, "b"); setResultUnsignedHex2(0, "result"); } return commandLengthValueForMode(mode, 4, 2); } else if (commandHeader == COMMAND_SIMPLE_TEST) { if (fillDeviceArgumentList) { setFunctionNoArgumentAndNoResult("simpleTest"); } return commandLengthValueForMode(mode, 0, 0); } else if (commandHeader == COMMAND_HEAVY_TEST) { if (fillDeviceArgumentList) { setFunction("heavyTest", 10, 1); setArgumentUnsignedHex2(0, "a"); setArgumentUnsignedHex2(1, "b"); setArgumentUnsignedHex4(2, "c"); setArgumentUnsignedHex4(3, "d"); setArgumentUnsignedHex2(4, "e"); setArgumentSeparator(5); setArgumentUnsignedHex2(6, "f"); setArgumentUnsignedHex4(7, "g"); setArgument(8, DEVICE_ARG_UNSIGNED_HEX_6, "h"); setArgumentUnsignedHex2(9, "i"); setResult(0, DEVICE_ARG_UNSIGNED_HEX_6, "result"); } return commandLengthValueForMode(mode, 29, 6); } // Debug Test else if (commandHeader == COMMAND_DEBUG_TEST) { if (fillDeviceArgumentList) { setFunctionNoArgumentAndNoResult("debugTest"); } return commandLengthValueForMode(mode, 0, 0); } else if (commandHeader == COMMAND_GENERATE_NOTIFY_TEST) { if (fillDeviceArgumentList) { setFunction("generateNotifyTest", 1, 0); setArgumentUnsignedHex2(0, "notifyTestValue"); } return commandLengthValueForMode(mode, 2, 0); } // Handle a notification test else if (mode == DEVICE_MODE_NOTIFY) { if (commandHeader == NOTIFY_TEST) { if (fillDeviceArgumentList) { setNotification("notifyTest", 1); setArgumentUnsignedHex2(0, "notifyArg0"); } return 2; } } return DEVICE_HEADER_NOT_HANDLED; }
Item::e_sercode Item::deserialize_function( Stream *file, VMachine *vm ) { if ( vm == 0 ) return sc_missvm; Symbol *sym; LiveModule *lmod; e_sercode sc = deserialize_symbol( file, vm, &sym, &lmod ); if ( sc != sc_ok ) return sc; // read the function called status if ( ! sym->isFunction() ) { // external function setFunction( new CoreFunc( sym, lmod ) ); return sc_ok; } // internal function. FuncDef *def = sym->getFuncDef(); // read the once status uint32 itemId = def->onceItemId(); if( itemId != FuncDef::NO_STATE ) { byte called; file->read( &called, 1 ); if( called ) lmod->globals()[ itemId ].setInteger( 1 ); else lmod->globals()[ itemId ].setNil(); } CoreFunc* function = new CoreFunc( sym, lmod ); // read the closure state. uint32 closlen; file->read( &closlen, sizeof( closlen ) ); if( closlen != 0 ) { ItemArray* closure = new ItemArray( closlen ); closure->resize( closlen ); // put the state in now, so we can destroy it in case of error. function->closure( closure ); // deserialize all the items. for( uint32 i = 0; i < closlen; i++ ) { Item::e_sercode res = (*closure)[i].deserialize(file, vm ); if ( res != sc_ok ) return res; } } setFunction( function ); return sc_ok; }
void FitDialog::showExpression(int function) { if (function < 0) return; if (categoryBox->currentRow() == 2) { explainBox->setText(MyParser::explainFunction(function)); } else if (categoryBox->currentRow() == 1) { polynomOrderLabel->show(); polynomOrderBox->show(); switch(funcBox->currentRow ()) { case 6: // Gauss polynomOrderLabel->setText(tr("Peaks")); explainBox->setText(MultiPeakFit::generateFormula(polynomOrderBox->value(), MultiPeakFit::Gauss)); break; case 7: // Lorentz polynomOrderLabel->setText(tr("Peaks")); explainBox->setText(MultiPeakFit::generateFormula(polynomOrderBox->value(), MultiPeakFit::Lorentz)); break; case 8: // Polynomial polynomOrderLabel->setText(tr("Polynomial Order")); explainBox->setText(PolynomialFit::generateFormula(polynomOrderBox->value())); break; default: polynomOrderLabel->hide(); polynomOrderBox->hide(); polynomOrderBox->setValue(1); explainBox->setText(d_built_in_functions[function]); } setFunction(boxUseBuiltIn->isChecked()); } else if (categoryBox->currentRow() == 0) { if (d_user_functions.size() > function) { QStringList l = d_user_functions[function].split("="); explainBox->setText(l[1]); } else explainBox->clear(); setFunction(boxUseBuiltIn->isChecked()); } else if (categoryBox->currentRow() == 3) { if (d_plugin_functions.size() > 0) { explainBox->setText(d_plugin_functions[function]); setFunction(boxUseBuiltIn->isChecked()); } else explainBox->clear(); } }
int deviceIOExpanderGetInterface(unsigned char commandHeader, DeviceInterfaceMode mode, bool fillDeviceArgumentList) { if (commandHeader == COMMAND_IO_EXPANDER_WRITE_SINGLE_BIT) { if (fillDeviceArgumentList) { setFunction("Write Single Bit", 5, 0); setArgumentUnsignedHex2(0, "IO Expander Index"); setArgumentSeparator(1); setArgumentUnsignedHex2(2, "IO Index"); setArgumentSeparator(3); setArgumentUnsignedChar1(4, "Value (bool)"); } return commandLengthValueForMode(mode, 7, 0); } if (commandHeader == COMMAND_IO_EXPANDER_WRITE_VALUE) { if (fillDeviceArgumentList) { setFunction("Write Value", 3, 0); setArgumentUnsignedHex2(0, "IO Expander Index"); setArgumentSeparator(1); setArgumentUnsignedHex2(2, "Value"); } return commandLengthValueForMode(mode, 5, 0); } else if (commandHeader == COMMAND_IO_EXPANDER_READ_SINGLE_BIT) { if (fillDeviceArgumentList) { setFunction("Read Single Bit", 3, 1); setArgumentUnsignedHex2(0, "IO Expander Index"); setArgumentSeparator(1); setArgumentUnsignedHex2(2, "IO Index"); setResultUnsignedChar1(0, "Value (bool)"); } return commandLengthValueForMode(mode, 5, 1); } else if (commandHeader == COMMAND_IO_EXPANDER_READ_VALUE) { if (fillDeviceArgumentList) { setFunction("Read Value", 1, 1); setArgumentUnsignedHex2(0, "IO Expander Index"); setResultUnsignedHex2(0, "Value"); } return commandLengthValueForMode(mode, 2, 2); } else if (commandHeader == COMMAND_IO_EXPANDER_DEBUG) { if (fillDeviceArgumentList) { setFunctionNoArgumentAndNoResult("Debug as Table"); } return commandLengthValueForMode(mode, 0, 0); } return DEVICE_HEADER_NOT_HANDLED; }
int deviceStrategy2018GetInterface(char commandHeader, DeviceInterfaceMode mode, bool fillDeviceArgumentList) { if (commandHeader == STRATEGY_2018_DISTRIBUTOR_DEBUG_COMMAND) { if (fillDeviceArgumentList) { setFunctionNoArgumentAndNoResult("Strategy 2018 Distributor Debug");; } return commandLengthValueForMode(mode, 0, 0); } else if (commandHeader == STRATEGY_2018_GET_SCORE) { if (fillDeviceArgumentList) { setFunction("Strategy 2018 Distributor Debug", 0, 1); setResultUnsignedHex2(0, "score"); } return commandLengthValueForMode(mode, 0, 2); } else if (commandHeader == STRATEGY_2018_READ_BALL_COLOR_TYPE) { if (fillDeviceArgumentList) { setFunctionNoArgumentAndNoResult("Strategy 2018 Read Color Type");; } return commandLengthValueForMode(mode, 0, 0); } else if (commandHeader == STRATEGY_2018_UNICOLOR_COMMAND) { if (fillDeviceArgumentList) { setFunctionNoArgumentAndNoResult("Strategy 2018 Unicolor");; } return commandLengthValueForMode(mode, 0, 0); } return DEVICE_HEADER_NOT_HANDLED; }
void Expression::fromParser(const Kernel::EParser& p) { m_op = p.operator_name(); bool special_case = p.name() == "+"; if (p.isFunct()) { // create the arguments first for(Kernel::EParser::iterator it=p.begin();it!= p.end();it++) { if (special_case &&((**it).name() == "-" && (**it).size() == 1)) { special_case = false; Expression* arg = new Expression(m_namespace,**((**it).begin())); arg->m_op = "-"; m_terms.push_back(boost::shared_ptr<Expression>(arg)); } else { Expression* arg = new Expression(m_namespace,**it); m_terms.push_back(boost::shared_ptr<Expression>(arg)); } } // set the function object setFunction(p.name()); } else { setVariable(p.name()); } }
//============================================================================== MidiSlider::MidiSlider(MiosStudio *_miosStudio, int _num, String _functionName, int _functionArg, int _midiChannel, int initialValue, bool _vertical) : miosStudio(_miosStudio) , sliderNum(_num) , vertical(_vertical) { addAndMakeVisible(slider = new MidiSliderComponent(T("Slider"))); slider->setSliderStyle(vertical ? MidiSliderComponent::LinearVertical : MidiSliderComponent::LinearHorizontal); slider->addListener(this); // only used for horizontal sliders addAndMakeVisible(sliderFunction = new ComboBox(String::empty)); sliderFunction->addListener(this); // restore settings PropertiesFile *propertiesFile = MiosStudioProperties::getInstance()->getCommonSettings(true); if( propertiesFile ) { _functionName = propertiesFile->getValue("slider" + String(sliderNum) + "FunctionName", _functionName); _functionArg = propertiesFile->getIntValue("slider" + String(sliderNum) + "FunctionArg", _functionArg); _midiChannel = propertiesFile->getIntValue("slider" + String(sliderNum) + "MidiChannel", _midiChannel); initialValue = propertiesFile->getIntValue("slider" + String(sliderNum) + "InitialValue", initialValue); } setFunction(_functionName, _functionArg, _midiChannel, initialValue); if( vertical ) setSize(24, 18+80); else setSize(128, 24+18); }
void SurfaceVisual::initialize() { m_VertexBuffer.resize( 4 ); m_VertexBuffer.allocHostMemory(); m_VertexBuffer[ 0 ] = LineVertex( 0.0f, 0.0f ); m_VertexBuffer[ 1 ] = LineVertex( 0.0f, 1.0f ); m_VertexBuffer[ 2 ] = LineVertex( 1.0f, 1.0f ); m_VertexBuffer[ 3 ] = LineVertex( 1.0f, 0.0f ); m_VertexBuffer.copyToDevice(); ShaderManager& shaders = engine.shaders; m_pVertexShader = shaders.getShader<Shader::Type::Vertex>( "line" ); m_pTessControlShader = shaders.getShader<Shader::Type::TessellationControl>( "surface" ); m_pTessEvalShader = Shader::fromName( Shader::Type::TessellationEvaluation, "surface" ); m_pFragmentShader = shaders.getShader<Shader::Type::Fragment>( "line" ); // setFunction( GpuFunctionSource( 2, 3, // "return vec3( v, 0.0 );" ) ); setFunction( GpuFunctionSource( 2, 3, "float R = 2.0;\n" "float rmin = 1.0;\n" "float rmax = R;\n" "float s = R - v.y * ( ( rmax - rmin ) * 0.5 * ( sin( t ) + 1.0 ) + rmin );\n" "return vec3( 10.0 * v.x - sin( 0.5 * t ) * 2.0 * ( ( s / R - 1.0 ) * ( s / R - 1.0 ) ), s * 2.0 * sin( 1.0 * f_time + PERIODS * v.x * TWO_PI ), s * 2.0 * cos( 1.0 * f_time + PERIODS * v.x * TWO_PI ) );" ) ); }
int commonBeaconDeviceGetInterface(char commandHeader, DeviceInterfaceMode mode, bool fillDeviceArgumentList) { // Redirection if (commandHeader == COMMAND_REDIRECT_TO_JENNIC) { // same output / input if (fillDeviceArgumentList) { setFunctionNoArgumentAndNoResult("redirectToJennic"); } return commandLengthValueForMode(mode, 0, 0); } else if (commandHeader == COMMAND_LOCAL_LIGHT) { if (fillDeviceArgumentList) { setFunction("localLight", 1, 2); setArgumentUnsignedHex2(2, "on/off"); } return commandLengthValueForMode(mode, 2, 0); } else if (commandHeader == COMMAND_SHOW_DATA_FROM_JENNIC) { // both input/output if (fillDeviceArgumentList) { setFunctionNoArgumentAndNoResult("showDataFromJennic"); } return commandLengthValueForMode(mode, 0, 0); } else if (commandHeader == COMMAND_RESET_JENNIC) { // both input/output if (fillDeviceArgumentList) { setFunctionNoArgumentAndNoResult("resetJennic"); } return commandLengthValueForMode(mode, 0, 0); } return DEVICE_HEADER_NOT_HANDLED; }
int deviceCodersGetInterface(char header, int mode, BOOL fillDeviceArgumentList) { if (header == COMMAND_CLEAR_CODERS) { // Same INPUT / OUTPUT if (fillDeviceArgumentList) { setFunctionNoArgument("clrCoders"); } return 0; } else if (header == COMMAND_GET_WHEEL_POSITION) { if (mode == DEVICE_MODE_INPUT) { if (fillDeviceArgumentList) { setFunctionNoArgument("codersVal"); } return 0; } else if (mode == DEVICE_MODE_OUTPUT) { if (fillDeviceArgumentList) { setFunction("codersVal", 3); setArgument(0, DEVICE_ARG_UNSIGNED_HEX_8, "left"); setArgumentSeparator(1); setArgument(2, DEVICE_ARG_UNSIGNED_HEX_8, "right"); } return 17; } } else if (header == COMMAND_DEBUG_GET_WHEEL_POSITION) { // Same INPUT / OUTPUT if (fillDeviceArgumentList) { setFunctionNoArgument("dbgCodersVal"); } return 0; } return DEVICE_HEADER_NOT_HANDLED; }
HRESULT APIENTRY OVRCreateDXGIFactory2( __in UINT flags, __in const IID &riid, __out void **ppFactory ) { HRESULT result = E_FAIL; restoreFunction( (PROC)oldCreateDXGIFactory2, oldCreateDXGIFactory2Data ); if (IN_COMPATIBILITY_MODE()) { result = (*oldCreateDXGIFactory2)(flags, riid, ppFactory); } else { WinCreateDXGIFactory2 createFunction = (WinCreateDXGIFactory2)GetProcAddress(rtFilterModule, "CreateDXGIFactory2"); result = (*createFunction)(flags, riid, ppFactory); } setFunction( (PROC)oldCreateDXGIFactory2, (PROC)OVRCreateDXGIFactory2, oldCreateDXGIFactory2Data ); printf("%s result 0x%x\n", __FUNCTION__, result); return result; }
HRESULT APIENTRY OVRCreateDXGIFactory1( __in REFIID riid, __out void **ppFactory ) { HRESULT result = E_FAIL; restoreFunction( (PROC)oldCreateDXGIFactory1, oldCreateDXGIFactory1Data ); if (IN_COMPATIBILITY_MODE()) { result = (*oldCreateDXGIFactory1)(riid, ppFactory); } else { WinCreateDXGIFactory1 createFunction = (WinCreateDXGIFactory1)GetProcAddress(rtFilterModule, "CreateDXGIFactory1"); result = (*createFunction)(riid, ppFactory); } setFunction( (PROC)oldCreateDXGIFactory1, (PROC)OVRCreateDXGIFactory1, oldCreateDXGIFactory1Data ); printf("%s result 0x%x\n", __FUNCTION__, result); return result; }
int deviceRobotConfigGetInterface(char commandHeader, DeviceInterfaceMode mode, bool fillDeviceArgumentList) { if (commandHeader == COMMAND_GET_CONFIG) { if (fillDeviceArgumentList) { setFunction("getConfig", 0, 1); setResultUnsignedHex4(0, "value"); } return commandLengthValueForMode(mode, 0, 4); } else if (commandHeader == COMMAND_SET_CONFIG) { if (fillDeviceArgumentList) { setFunction("setConfig", 1, 0); setArgumentUnsignedHex4(0, "value"); } return commandLengthValueForMode(mode, 4, 0); } return DEVICE_HEADER_NOT_HANDLED; }
bool CPlayButton::onMouseMsg( MouseMsg const& msg ) { if ( msg.onLeftDown() ) { if ( m_playInfo.type == PT_NULL ) return false; sDragIcon->removeRectArea( 0 ); setupPlayIcon( sDragIcon ); sDragIcon->show( true ); Vec3D pos = mSprite->getWorldPosition(); pos[2] = -8000; sDragIcon->setWorldPosition( pos ); CUISystem::getInstance().captureMouse( this ); } else if ( msg.onLeftUp() ) { CUISystem::getInstance().releaseMouse(); sDragIcon->show( false ); CWidget* ui = CUISystem::getInstance().hitTest( msg.getPos() ); if ( ui != this ) { if ( ui ) { CPlayButton* playbutton = dynamic_cast< CPlayButton* >( ui ) ; if ( playbutton ) playbutton->onInputItem( this ); } else { if ( m_cbType == CBT_FAST_PLAY_BAR ) setFunction( NULL , NULL ); } // skip OnClick return false; } } if ( msg.isLeftDown() && msg.isDraging() ) { if ( sDragIcon->isShow() ) { Vec2i const& size = getSize(); MouseMsg const& msg = CUISystem::getInstance().getLastMouseMsg(); sDragIcon->setWorldPosition( Vec3D( msg.x() - size.x/2 , msg.y() - size.y/2 , -8000 ) ); } } CButtonUI::onMouseMsg( msg ); return false; }
void HybridComp::SetUpFRH002_Com_CEC05() { string fname[m_numFuncs]; unsigned fid[m_numFuncs]; for(int i=0;i<m_numFuncs;i++){ mp_height[i]=100*i; } fname[0] = "FUN_Weierstrass"; fname[1] = "FUN_Expanded_Scaffer_F6_CEC05"; fname[2] = "FUN_Griewank_Rosenbrock_F13_CEC05"; fname[3] = "FUN_Ackley"; fname[4] = "FUN_Rastrigin"; fname[5] = "FUN_Griewank"; fname[6] = "FUN_Noncont_Expanded_Scaffer_F6_CEC05"; fname[7] = "FUN_Noncont_Rastrigin"; fname[8] = "FUN_Elliptic"; fname[9] = "FUN_Sphere_Noisy_CEC05"; mp_stretchSeverity[0]=10; mp_convergeSeverity[0]=2.; for(int i=0;i<m_numFuncs;i++) fid[i]=Global::msm_pro[fname[i]]; setFunction(fid,fname); mpp_f[0]->setSearchRange(-0.5,0.5); mpp_f[1]->setSearchRange(-100, 100); mpp_f[2]->setSearchRange(-5,5); mpp_f[3]->setSearchRange(-32,32); mpp_f[4]->setSearchRange(-5,5); mpp_f[5]->setSearchRange(-5,5); mpp_f[6]->setSearchRange(-100, 100); mpp_f[7]->setSearchRange(-5,5); mpp_f[8]->setSearchRange(-100,100); mpp_f[9]->setSearchRange(-100,100); mp_stretchSeverity[1]=5.0/20; mp_stretchSeverity[2]=1.0; mp_stretchSeverity[3]=5.0/32; mp_stretchSeverity[4]=1.0; mp_stretchSeverity[5]=5.0/100; mp_stretchSeverity[6]=5.0/50; mp_stretchSeverity[7]=1.0; mp_stretchSeverity[8]=5.0/100; mp_stretchSeverity[9]=5.0/100; mp_convergeSeverity[1]=2.; mp_convergeSeverity[2]=2.; mp_convergeSeverity[3]=2.; mp_convergeSeverity[4]=2.; mp_convergeSeverity[5]=2.; mp_convergeSeverity[6]=2; mp_convergeSeverity[7]=2; mp_convergeSeverity[8]=2.; mp_convergeSeverity[9]=2.; for(int i=0;i<m_numFuncs;i++){ mpp_f[i]->setScale(mp_stretchSeverity[i]); } setBias(260); }
int deviceTest2GetInterface(char commandHeader, int mode, bool fillDeviceArgumentList) { if (commandHeader == COMMAND_TEST2) { if (fillDeviceArgumentList) { setFunction("test2", 2, 1); setArgumentUnsignedHex2(0, "a"); setArgumentUnsignedHex2(1, "b"); setResultUnsignedHex2(0, "result"); } return commandLengthValueForMode(mode, 4, 2); } else if (commandHeader == COMMAND_INTENSIVE_TEST_DRIVER) { if (fillDeviceArgumentList) { setFunction("testDriverIntensive", 1, 0); setArgumentUnsignedHex4(0, "count"); } return commandLengthValueForMode(mode, 4, 0); } return DEVICE_HEADER_NOT_HANDLED; }
int deviceBatteryGetInterface(unsigned char commandHeader, DeviceInterfaceMode mode, bool fillDeviceArgumentList){ if (commandHeader == COMMAND_READ_BATTERY ) { if (fillDeviceArgumentList) { setFunction("Battery Read", 0, 1); setResultUnsignedHex4(0, "Battery Value (mV)"); } return commandLengthValueForMode(mode, 0, 4); } return DEVICE_HEADER_NOT_HANDLED; }
Token::Token(std::string str, bool is_function) : token_string(str){ if(is_function){ setFunction(str); } else{ is_partial = true; token_type = ID_UNDEFINED; setType(); } }
int deviceFileGetInterface(char header, DeviceInterfaceMode mode, bool fillDeviceArgumentList){ if (header == COMMAND_CREATE_FILE_SYSTEM) { if (fillDeviceArgumentList) { setFunctionNoArgumentAndNoResult("Create File System"); } return 0; } else if (header == COMMAND_GET_FREE_SPACE) { if (fillDeviceArgumentList) { setFunction("Get Free Space", 0, 1); setResultUnsignedHex4(0, "result"); } return commandLengthValueForMode(mode, 0, 4); } else if (header == COMMAND_SHOW_LIST_FILE ) { if (fillDeviceArgumentList) { setFunctionNoArgumentAndNoResult("Show File List"); } return 0; } else if (header == COMMAND_SHOW_CONTENT_FILE) { if (fillDeviceArgumentList) { setFunction("Show File Content", 1, 0); setArgumentUnsignedHex2(0, "fileIndex"); } return commandLengthValueForMode(mode, 2, 0); } else if (header == COMMAND_CREATE_NEW_FILE) { if (fillDeviceArgumentList) { setFunction("Create New File", 1, 0); setArgumentUnsignedHex2(0, "fileIndex"); } return commandLengthValueForMode(mode, 2, 0); } else if (header == COMMAND_DELETE_FILE) { if (fillDeviceArgumentList) { setFunction("Delete File", 1, 0); setArgumentUnsignedHex2(0, "fileIndex"); } return commandLengthValueForMode(mode, 2, 0); } return DEVICE_HEADER_NOT_HANDLED; }
void ControllerPosition::setProperty(const std::string& _key, const std::string& _value) { if (_key == "Time") setTime(utility::parseValue<float>(_value)); else if (_key == "Coord") setCoord(utility::parseValue<IntCoord>(_value)); else if (_key == "Size") setSize(utility::parseValue<IntSize>(_value)); else if (_key == "Position") setPosition(utility::parseValue<IntPoint>(_value)); else if (_key == "Function") setFunction(_value); }
int deviceI2cSlaveDebugGetInterface(unsigned char commandHeader, DeviceInterfaceMode mode, bool fillDeviceArgumentList) { if (commandHeader == COMMAND_I2C_DEBUG_SLAVE_DEBUG) { if (fillDeviceArgumentList) { setFunctionNoArgumentAndNoResult("i2cDebug"); } return commandLengthValueForMode(mode, 0, 0); } else if (commandHeader == COMMANG_I2C_DEBUG_SLAVE_ADDRESS) { if (fillDeviceArgumentList) { setFunction("i2cSlaveAddress", 0, 1); setResultUnsignedHex2(0, "i2cAddress"); } return commandLengthValueForMode(mode, 0, 2); } else if (commandHeader == COMMAND_I2C_DEBUG_SLAVE_ENABLE_DISABLE) { if (fillDeviceArgumentList) { setFunction("enable/disable", 1, 0); setArgumentUnsignedHex2(0, "mode"); } return commandLengthValueForMode(mode, 2, 0); } else if (commandHeader == COMMAND_I2C_DEBUG_SLAVE_SEND_CHAR_I2C_TO_MASTER) { if (fillDeviceArgumentList) { setFunction("sendCharI2cToMaster", 1, 0); setArgumentUnsignedHex2(0, "char"); } return commandLengthValueForMode(mode, 2, 0); } else if (commandHeader == COMMAND_I2C_DEBUG_SLAVE_READ_CHAR_I2C_FROM_MASTER) { if (fillDeviceArgumentList) { setFunction("readCharI2cFromMaster", 0, 1); setResultUnsignedHex2(0, "result"); } return commandLengthValueForMode(mode, 0, 2); } return DEVICE_HEADER_NOT_HANDLED; }
// Default constructor that initializes // this formation to the parameterized values. Formation::Formation(const Function f, const float r, const Vector sGrad, const int sID, const int fID, const float theta) { setFunction(f); setRadius(r); setSeedFrp(sGrad); setSeedID(sID); setFormationID(fID); setHeading(theta); }
// // Formation(f, r, sGrad, sID, fID, theta) // Last modified: 04Sep2006 // // Default constructor that initializes // this formation to the parameterized values. // // Returns: <none> // Parameters: // f in the initial function of the formation // r in the initial radius of the formation // sGrad in the initial seed gradient of the formation // sID in the initial seed ID of the formation // fID in the initial ID of the formation // theta in the initial heading of the formation // Formation::Formation(const Function f, const GLfloat r, const Vector sGrad, const GLint sID, const GLint fID, const GLfloat theta) { setFunction(f); setRadius(r); setSeedGradient(sGrad); setSeedID(sID); setFormationID(fID); setHeading(theta); } // Formation(const..{Function, GLfloat, Vector, GLint, GLint, GLfloat})
int deviceTestGetInterface(char header, int mode, BOOL fillDeviceArgumentList) { if (header == COMMAND_TEST) { if (mode == DEVICE_MODE_INPUT) { if (fillDeviceArgumentList) { setFunction("test", 2); setArgumentUnsignedHex2(0, "arg1"); setArgumentUnsignedHex2(1, "arg2"); } return 4; } else if (mode == DEVICE_MODE_OUTPUT) { if (fillDeviceArgumentList) { setFunction("test", 1); setArgumentUnsignedHex2(0, "result"); } return 2; } }// Describe a notification test else if (header == COMMAND_NOTIFY_TEST) { if (mode == DEVICE_MODE_INPUT) { if (fillDeviceArgumentList) { setFunction("notifyTest", 1); setArgumentUnsignedHex2(0, "arg"); } return 2; } else if (mode == DEVICE_MODE_OUTPUT) { if (fillDeviceArgumentList) { setFunction("notifyTest", 1); setArgumentUnsignedHex2(0, "arg"); } return 2; } } return DEVICE_HEADER_NOT_HANDLED; }
void GPIO::init() { /* * set all pins to "output" and "low" */ return; //debug unsigned char i, j; for (i = 0; i <= 9; i++) { if ( i == 4 ) { continue; } for (j = 0; j < 16; j++) { setFunction(i, j, GPIO_FUNCTION_INPUT_PULLDOWN); } } }
void HybridComp::SetUpFRH_Com_CEC05(){ string fname[m_numFuncs]; unsigned fid[m_numFuncs]; for(int i=0;i<m_numFuncs;i++){ mp_height[i]=100*i; } fname[0]="FUN_Ackley"; fname[1]="FUN_Ackley"; fname[2]="FUN_Rastrigin"; fname[3]="FUN_Rastrigin"; fname[4]="FUN_Sphere"; fname[5]="FUN_Sphere"; fname[6]="FUN_Weierstrass"; fname[7]="FUN_Weierstrass"; fname[8]="FUN_Griewank"; fname[9]="FUN_Griewank"; if(IS_PROBLEM_NAME( m_id,"FUN_RH_Com_NarrowBasin_CEC05")) { mp_stretchSeverity[0]=0.1*5./32; mp_convergeSeverity[0]=0.1; }else{ mp_stretchSeverity[0]=2.*5./32; mp_convergeSeverity[0]=1.; } for(int i=0;i<m_numFuncs;i++) fid[i]=Global::msm_pro[fname[i]]; setFunction(fid,fname); mpp_f[0]->setSearchRange(-32,32); mpp_f[1]->setSearchRange(-32,32); mpp_f[2]->setSearchRange(-5,5); mpp_f[3]->setSearchRange(-5,5); mpp_f[4]->setSearchRange(-100,100); mpp_f[5]->setSearchRange(-100,100); mpp_f[6]->setSearchRange(-0.5,0.5); mpp_f[7]->setSearchRange(-0.5,0.5); mpp_f[8]->setSearchRange(-60,60); mpp_f[9]->setSearchRange(-60,60); mp_stretchSeverity[1]=5./32; mp_stretchSeverity[2]=2.; mp_stretchSeverity[3]=1.; mp_stretchSeverity[4]=2*5./100; mp_stretchSeverity[5]=5./100; mp_stretchSeverity[6]=20.; mp_stretchSeverity[7]=10.; mp_stretchSeverity[8]=2.*5/60; mp_stretchSeverity[9]=5./60; mp_convergeSeverity[1]=2.; mp_convergeSeverity[2]=1.5; mp_convergeSeverity[3]=1.5; mp_convergeSeverity[4]=1.; mp_convergeSeverity[5]=1.; mp_convergeSeverity[6]=1.5; mp_convergeSeverity[7]=1.5; mp_convergeSeverity[8]=2.; mp_convergeSeverity[9]=2.; for(int i=0;i<m_numFuncs;i++){ mpp_f[i]->setScale(mp_stretchSeverity[i]); } setBias(10.); }
static state updateState(state r, int previousStep, double point) { double firstDerivative[DOF]; double function[DOF]; int i; for (i = 0; i < DOF; i++) { firstDerivative[i] = firstDeriv_n[i] + point*rk4secondDeriv[previousStep][i]; function[i] = function_n[i] + point*rk4firstDeriv[previousStep][i]; } r = setFirstDeriv(r, firstDerivative); r = setFunction(r, function); return r; }