FUNCTION(func_control_menu_ischecked,Checked) { setmemberfunction(SC_valname_control_menu); addvar(_qstr("ID"),SC_valname_string); setreturntype(SC_valname_boolean); setcanassign(); }
/* list flags and values that you want to receive via -x */ void upsdrv_makevartable(void) { char buf[SMALLBUF]; snprintf(buf, sizeof(buf), "network timeout (default: %d seconds)", timeout); addvar(VAR_VALUE, "timeout", buf); addvar(VAR_FLAG, "subscribe", "authenticated subscription on NMC"); addvar(VAR_VALUE | VAR_SENSITIVE, "login", "login value for authenticated mode"); addvar(VAR_VALUE | VAR_SENSITIVE, "password", "password value for authenticated mode"); snprintf(buf, sizeof(buf), "shutdown duration in second (default: %d seconds)", shutdown_duration); addvar(VAR_VALUE, "shutdown_duration", buf); if( shutdown_timer > 0 ) { snprintf(buf, sizeof(buf), "shutdown timer in second (default: %d seconds)", shutdown_timer); } else { snprintf(buf, sizeof(buf), "shutdown timer in second (default: none)"); } addvar(VAR_VALUE, "shutdown_timer", buf); /* Legacy MGE-XML conversion from 2000's, not needed in modern firmwares */ addvar(VAR_FLAG, "do_convert_deci", "enable legacy convert_deci() for certain measurements 10x too large"); }
ssize_t addvard(struct dhcpcd_ctx *ctx, char ***e, const char *prefix, const char *var, size_t value) { char buffer[32]; snprintf(buffer, sizeof(buffer), "%zu", value); return addvar(ctx, e, prefix, var, buffer); }
FUNCTION(func_starglobe_getconlines,GetConLines) { setmemberfunction(SC_valname_starglobe); addvar(_qstr("ConstellationID"),SC_valname_string); setreturntype(SC_valname_list); //addvar(_qstr("Content"),SC_valname_string); //addvar(_qstr("ID"),SC_valname_string,false); //addvar(_qstr("CanCheck"),SC_valname_boolean,false); }
TSC_script_customfunc::TSC_script_customfunc(StrPtr ifuncname, Tarray<QString> &argnames, TSC_script_block *iblock) : TSC_func(ifuncname) { setreturntype(SC_valname_any); for (int i=0; i<argnames.G_count(); i++) addvar(*argnames[i],SC_valname_any); block=iblock; block->Set_isfunctionblock(ifuncname); }
/* list flags and values that you want to receive via -x */ void upsdrv_makevartable(void) { /* allow '-x xyzzy' */ /* addvar(VAR_FLAG, "xyzzy", "Enable xyzzy mode"); */ /* allow '-x foo=<some value>' */ /* addvar(VAR_VALUE, "foo", "Override foo setting"); */ addvar(VAR_VALUE, "model", "Regular Expression to match power source model name"); }
/* list flags and values that you want to receive via -x */ void upsdrv_makevartable(void) { addvar(VAR_VALUE, "manufacturer", "manufacturer [unknown]"); addvar(VAR_VALUE, "baudrate", "Serial interface baudrate [1200]"); addvar(VAR_VALUE, "input_timeout", "Command response timeout [2]"); addvar(VAR_VALUE, "output_pace", "Output character delay in usecs [200]"); addvar(VAR_VALUE, "full_update", "Delay between full value downloads [60]"); addvar(VAR_FLAG, "use_crlf", "Use CR-LF to terminate commands to UPS"); addvar(VAR_FLAG, "use_pre_lf", "Use LF to introduce commands to UPS"); }
void upsdrv_makevartable(void) { addvar(VAR_VALUE, "panel.voltage", "Override nominal battery voltage"); addvar(VAR_VALUE, "panel.current", "Battery voltage multiplier"); addvar(VAR_VALUE, "panel.kw", "Override nominal battery voltage"); addvar(VAR_VALUE, "panel.kwh", "Battery voltage multiplier"); addvar(VAR_VALUE, "inverter.status", "Battery voltage multiplier"); addvar(VAR_VALUE, "charge.solar", "Battery voltage multiplier"); addvar(VAR_VALUE, "error.status", "Battery voltage multiplier"); }
void blazer_makevartable(void) { addvar(VAR_VALUE, "ondelay", "Delay before UPS startup (minutes)"); addvar(VAR_VALUE, "offdelay", "Delay before UPS shutdown (seconds)"); addvar(VAR_VALUE, "runtimecal", "Parameters used for runtime calculation"); addvar(VAR_VALUE, "chargetime", "Nominal charge time for UPS battery"); addvar(VAR_VALUE, "idleload", "Minimum load to be used for runtime calculation"); addvar(VAR_FLAG, "norating", "Skip reading rating information from UPS"); addvar(VAR_FLAG, "novendor", "Skip reading vendor information from UPS"); addvar(VAR_FLAG, "protocol", "Preselect communication protocol (skip autodetection)"); }
static Node* staticname(Type *t, int ctxt) { Node *n; snprint(namebuf, sizeof(namebuf), "statictmp_%.4d", statuniqgen); statuniqgen++; n = newname(lookup(namebuf)); if(!ctxt) n->readonly = 1; addvar(n, t, PEXTERN); return n; }
int colgen_generate (colgen_t* colgenp, int commodity) // attempts to generate a new column for the master problem, with a negative reduced cost, // returns 1 on success, 0 on failure. { int i, c; int size, col_nzcnt = 0; double ucost = 0.0; // unit cost of the path // walk through the shortest path for (c = colgenp->instp->commod_dest_node[commodity]; c != colgenp->instp->commod_orig_node[commodity]; c = colgenp->graph[commodity].pred_node[c]) { i = colgenp->graph[commodity].pred_arc[c]; if (i == colgenp->instp->n_arcs) // test if the shortest path has the artificial arc return 0; ucost += colgenp->instp->arc_commod_ucost[i][commodity] + colgenp->commod_arc_lfactor[commodity][i]; // update path unit cost colgenp->col_ind[col_nzcnt++] = i; // add index to constraint coefficient matrix column } qsort(colgenp->col_ind, col_nzcnt, sizeof(int), arc_cmp); // sort column indices in ascending order colgenp->col_ind[col_nzcnt++] = colgenp->instp->n_arcs + commodity; // add bundle constraint coefficient // reallocate array space for path attributes, using a fibonacci sequence: new_size = old_size + older_size; if (colgenp->n_paths == colgenp->current_alloc) { size = colgenp->current_alloc; colgenp->current_alloc += colgenp->prev_alloc; colgenp->prev_alloc = size; colgenp->path_ucost = (realloc(colgenp->path_ucost, colgenp->current_alloc * sizeof(double))); colgenp->path_flow = (realloc(colgenp->path_flow, colgenp->current_alloc * sizeof(double))); colgenp->path_commod = (realloc(colgenp->path_commod, colgenp->current_alloc * sizeof(int))); colgenp->path_arcs = (realloc(colgenp->path_arcs, colgenp->current_alloc * sizeof(char*))); for (c = size; c < colgenp->current_alloc; c++) colgenp->path_arcs[c] = (calloc(colgenp->instp->n_arcs, sizeof(char))); } // store the arc composition of the new column for (i = 0; i < colgenp->instp->n_arcs; i++) colgenp->path_arcs[colgenp->n_paths][i] = 0; for (c = 0; c < col_nzcnt - 1; c++) { i = colgenp->col_ind[c]; colgenp->path_arcs[colgenp->n_paths][i] = 1; } // store its other attributes colgenp->path_ucost[colgenp->n_paths] = ucost; colgenp->path_flow[colgenp->n_paths] = 0.0; colgenp->path_commod[colgenp->n_paths] = commodity; ++colgenp->n_paths; // add the column GRB(addvar(colgenp->lp, col_nzcnt, colgenp->col_ind, colgenp->col_val, ucost, 0.0, colgenp->instp->commod_supply[commodity], GRB_CONTINUOUS, NULL)); return 1; }
void upsdrv_makevartable(void) { addvar(VAR_VALUE, "offdelay", "Delay before outlet shutdown (seconds)"); addvar(VAR_VALUE, "ondelay", "Delay before outlet startup (seconds)"); addvar(VAR_VALUE, "mincharge", "Remaining battery level when UPS switches to LB (percent)"); addvar(VAR_VALUE, "minruntime", "Remaining battery runtime when UPS switches to LB (seconds)"); addvar(VAR_VALUE, "load.off", "Command to switch off outlet"); addvar(VAR_VALUE, "load.on", "Command to switch on outlet"); addvar(VAR_VALUE, "load.status", "Variable that indicates outlet is on/off"); }
void upsdrv_makevartable(void) { addvar(VAR_VALUE, "subdriver", "Serial-over-USB subdriver selection"); addvar(VAR_VALUE, "vendorid", "Regular expression to match UPS Manufacturer numerical ID (4 digits hexadecimal)"); addvar(VAR_VALUE, "productid", "Regular expression to match UPS Product numerical ID (4 digits hexadecimal)"); addvar(VAR_VALUE, "vendor", "Regular expression to match UPS Manufacturer string"); addvar(VAR_VALUE, "product", "Regular expression to match UPS Product string"); addvar(VAR_VALUE, "serial", "Regular expression to match UPS Serial number"); addvar(VAR_VALUE, "bus", "Regular expression to match USB bus name"); addvar(VAR_VALUE, "langid_fix", "Apply the language ID workaround to the krauler subdriver (0x409 or 0x4095)"); blazer_makevartable(); }
void upsdrv_makevartable(void) { addvar(VAR_VALUE, "ondelay", "Delay before UPS startup"); addvar(VAR_VALUE, "offdelay", "Delay before UPS shutdown"); addvar(VAR_VALUE, "manufacturer", "manufacturer"); addvar(VAR_VALUE, "model", "modelname"); addvar(VAR_VALUE, "serial", "serialnumber"); addvar(VAR_VALUE, "protocol", "protocol to use [text|binary] (default: autodection)"); }
static int newnum(char *name, char *arg) { numvar_t *n = NULL; int res = 0; if (!(n = calloc(sizeof(numvar_t)))) return ERRNOMEM; n->num = str2int(arg); res = addvar((var_t*)n, name, NUMTYPE); if(res) free(n); return res; }
size_t ebasearrayof::unserial(const estr& data,size_t i) { unsigned int count; evar keyvar,var; i=unserialint(count,data,i); if (i==-1) return(-1); while(count && i<data.len()){ keyvar.clear(); var.clear(); i=keyvar.unserial(data,i); if (i==-1) return(-1); i=var.unserial(data,i); if (i==-1) return(-1); addvar(keyvar,var); --count; } if (count) return(-1); return(i); }
int main(int argc, char **argv) { int n = 0; if (*++argv) { n = atoi(*argv); } n = (n)?n:6; struct tnode *root; char vname[MAXVAR]; root = NULL; while (getvariable(vname)) { root = addvar(root, vname, n); } treeprint(root); return 0; }
static int newview(char *name, char *arg) { viewvar_t *v = NULL; arrvar_t *a = NULL; int i = 0; int res = 0; char *type = strtok(NULL,' '); if (!type || strlen(type) == 0) return ERRNOTYPE; if (!(a = (arrvar_t*)getvar(arg))) return ERRNOSUCHVAR; if (a->v.type != ARRTYPE) return ERRWRONGTYPE; if (!(v = calloc(sizeof(viewvar_t)))) return ERRNOMEM; for (i=0; i < sizeof(viewtypes)/sizeof(viewtype_t); i++) { if (streq(type,viewtypes[i].name)) { v->view = &viewtypes[i]; break; } } if (!v->view) { free(v); return ERRNOSUCHTYPE; } v->arr = a; res = addvar((var_t*)v, name, VIEWTYPE); if (res) free(v); return res; }
static int newarr(char *name, char *arg) { arrvar_t *a = NULL; int res = 0; uint32_t size = str2uint(arg); if (size > MAXARRSIZE) return ERRTOOBIG; if (!(a = calloc(sizeof(arrvar_t)+(size*sizeof(int))))) return ERRNOMEM; a->size = size*sizeof(int); res = addvar((var_t*)a, name, ARRTYPE); if (res) free(a); return res; }
FUNCTION(func_2dcontourset_create,Contour) { setclasspath_fromtype(SC_valname_2dcontourset); addvar(_qstr("pointlist"),SC_valname_list); setreturntype(SC_valname_2dcontourset); }
FUNCTION(func_2dcontourset_addpoint,addpoint) { setmemberfunction(SC_valname_2dcontourset); addvar(_qstr("point"),SC_valname_vertex); addvar(_qstr("normal"),SC_valname_vector,false); }
void upsdrv_makevartable(void) { addvar(VAR_VALUE, "cablepower", "Set cable power for serial interface"); blazer_makevartable(); }
colgen_t colgen_create (cmnd_t* instp) { colgen_t colgen; int i, k; char* sense = (char*) (malloc((instp->n_commods + instp->n_arcs) * sizeof(char))); colgen.instp = instp; colgen.graph = (malloc(instp->n_commods * sizeof(simple_graph_t))); colgen.overflow = 1; colgen.n_paths = colgen.prev_alloc = colgen.current_alloc = instp->n_commods; colgen.arc_cap = (malloc((instp->n_arcs + instp->n_commods) * sizeof(double))); colgen.arc_mul = (malloc(instp->n_arcs * sizeof(double))); colgen.overflow_mul = (malloc(instp->n_commods* sizeof(double))); colgen.commod_mul = (malloc(instp->n_commods * sizeof(double))); colgen.col_val = (malloc((2 + instp->n_arcs) * sizeof(double))); colgen.col_ind = (malloc((2 + instp->n_arcs) * sizeof(int))); colgen.path_ucost = (malloc(instp->n_commods * sizeof(double))); colgen.path_flow = (malloc(instp->n_commods * sizeof(double))); colgen.path_commod = (malloc(instp->n_commods * sizeof(int))); colgen.arc_total_flow = (malloc(instp->n_arcs * sizeof(double))); colgen.arc_total_ucost = (malloc(instp->n_arcs * sizeof(double))); colgen.arc_open = (malloc(instp->n_arcs * sizeof(int))); colgen.best_arc_open = (malloc(instp->n_arcs * sizeof(int))); colgen.commod_arc_flow = (malloc(instp->n_commods * sizeof(double*))); colgen.path_arcs = (malloc(colgen.current_alloc * sizeof(char*))); colgen.commod_arc_lfactor = (malloc(instp->n_commods * sizeof(double*))); for (i = 0; i < instp->n_arcs; i++) { sense[i] = GRB_LESS_EQUAL; // sense of capacity constraints colgen.arc_cap[i] = instp->arc_capacity[i]; // initial right-hand sides of capacity constraints colgen.col_val[i] = 1.0; } colgen.col_val[instp->n_arcs] = 1.0; for (k = 0; k < instp->n_commods; k++) { colgen.commod_arc_lfactor[k] = (malloc(instp->n_arcs * sizeof(double))); for (i = 0; i < instp->n_arcs; i++) colgen.commod_arc_lfactor[k][i] = 0.0; // default linearization factors colgen.path_arcs[k] = (calloc(instp->n_arcs, sizeof(char))); sense[instp->n_arcs + k] = GRB_EQUAL; // sense of bundle constraints colgen.arc_cap[instp->n_arcs + k] = instp->commod_supply[k]; // right-hand sides of bundle constraints colgen.graph[k] = simple_graph_create(instp); // pricing graph creation colgen.commod_arc_flow[k] = (malloc(instp->n_arcs * sizeof(double))); } // master problem creation GRB(newmodel(env, &colgen.lp, "CMNF path-based formulation", 0, NULL, NULL, NULL, NULL, NULL)); // the first n_arcs constraints are the capacity constraints GRB(addconstrs(colgen.lp, instp->n_arcs, 0, NULL, NULL, NULL, sense, colgen.arc_cap, NULL)); // followed by n_commods bundle constraints GRB(addconstrs(colgen.lp, instp->n_commods, 0, NULL, NULL, NULL, &sense[instp->n_arcs], instp->commod_supply, NULL)); GRB(updatemodel(colgen.lp)); // overflow paths creation (paths containing only the artificial arc from source to sink for each commodity) for (k = 0; k < instp->n_commods; k++) { colgen.path_ucost[k] = instp->commod_overflow_ucost[k]; colgen.path_flow[k] = 0.0; colgen.path_commod[k] = k; colgen.col_ind[0] = instp->n_arcs + k; GRB(addvar(colgen.lp, 1, colgen.col_ind, colgen.col_val, colgen.path_ucost[k], 0.0, instp->commod_supply[k], GRB_CONTINUOUS, NULL)); } GRB(updatemodel(colgen.lp)); // solver parameter settings GRB(setintparam(env, GRB_INT_PAR_METHOD, 1)); // optimization GRB(optimize(colgen.lp)); GRB(getintattr(colgen.lp, GRB_INT_ATTR_STATUS, &grb_status)); assert(grb_status == GRB_OPTIMAL); // initial primal and dual values GRB(getdblattrarray(colgen.lp, GRB_DBL_ATTR_X, 0, colgen.n_paths, colgen.path_flow)); GRB(getdblattrarray(colgen.lp, GRB_DBL_ATTR_PI, 0, instp->n_arcs, colgen.arc_mul)); GRB(getdblattrarray(colgen.lp, GRB_DBL_ATTR_PI, instp->n_arcs, instp->n_commods, colgen.commod_mul)); // initial bounds on the optimal objective value colgen.z_lb = 0.0; colgen.z_ub = inf; return colgen; }
void symmodel::addivars( const string& s, const string& t, const vector<size_t>& i ) { addvar( s, t ); vars[ vars.size() - 1 ]->addivalus( i ); }
void symmodel::addfvars( const string& s, const string& t, const vector<real_t>& f ) { addvar( s, t ); vars[ vars.size() - 1 ]->addfvalus( f ); }
/* list flags and values that you want to receive via -x */ void upsdrv_makevartable(void) { addvar (VAR_VALUE, "baudrate", "serial line speed"); }
/* list flags and values that you want to receive via -x or ups.conf */ void upsdrv_makevartable(void) { addvar(VAR_VALUE, "lowbatt", "Set low battery level, in percent"); }
/* Subdriver-specific flags/vars * NOTE: this 'light' version only handles vars/flags related to UPS status query (Q1/QS/D/...) */ void blazer_makevartable_light(void) { addvar(VAR_FLAG, "ignoresab", "Ignore 'Shutdown Active' bit in UPS status"); }
/* define possible arguments */ void upsdrv_makevartable(void) { // 1 2 3 4 5 6 7 8 //2345678901234567890123456789012345678901234567890123456789012345678901234567890 MAX addvar(VAR_VALUE, "type", "Type of UPS: 'Trust','Egys','KP625AP','IMP','KIN','BNT','BNT-other','OPTI'\n" " (default: 'Trust')"); addvar(VAR_VALUE, "manufacturer", "Manufacturer name (default: 'PowerCom')"); addvar(VAR_VALUE, "modelname", "Model name [cannot be detected] (default: Unknown)"); addvar(VAR_VALUE, "serialnumber", "Serial number [cannot be detected] (default: Unknown)"); addvar(VAR_VALUE, "shutdownArguments", "Delay values for shutdown: Minutes, Seconds, UseMinutes?'y'or'n'"); addvar(VAR_VALUE, "linevoltage", "Line voltage 110-120 or 220-240 V (default: 230)"); addvar(VAR_VALUE, "numOfBytesFromUPS", "The number of bytes in a UPS frame"); addvar(VAR_VALUE, "methodOfFlowControl", "Flow control method for UPS: 'dtr0rts1' or 'no_flow_control'"); addvar(VAR_VALUE, "validationSequence", "Validation values: ByteIndex, ByteValue x 3"); if ( strcmp(types[type].name, "KIN") && strcmp(types[type].name, "BNT") && strcmp(types[type].name, "IMP")) { addvar(VAR_VALUE, "frequency", "Frequency conversion values: FreqFactor, FreqConst"); addvar(VAR_VALUE, "loadPercentage", "Load conversion values: OffFactor, OffConst, OnFactor, OnConst"); addvar(VAR_VALUE, "batteryPercentage", "Battery conversion values: OffFactor, LoadFactor, OffConst, OnFactor, OnConst"); addvar(VAR_VALUE, "voltage", "Voltage conversion values: 240VFactor, 240VConst, 120VFactor, 120VConst"); } }
FUNCTION(func_control_select,ActivateControl) { addvar(_qstr("control"),SC_valname_any); extendclasspath(SC_treeclass_controls); }