void exec( ) throw( general_error ) { iec61853_module_t solver; msg_handler msgs( *this ); solver._imsg = &msgs; util::matrix_t<double> input = as_matrix("input"), par; if ( input.ncols() != iec61853_module_t::COL_MAX ) throw exec_error( "iec61853", "six data columns required for input matrix: IRR,TC,PMP,VMP,VOC,ISC"); if (!solver.calculate( input, as_integer("nser"), as_integer("type"), par, as_boolean("verbose") )) throw exec_error( "iec61853", "failed to solve for parameters"); assign("n", var_data((ssc_number_t)solver.n)); assign("alphaIsc", var_data((ssc_number_t)solver.alphaIsc)); assign("betaVoc", var_data((ssc_number_t)solver.betaVoc)); assign( "gammaPmp", var_data((ssc_number_t)solver.gammaPmp) ); assign( "Il", var_data((ssc_number_t)solver.Il) ); assign( "Io", var_data((ssc_number_t)solver.Io) ); assign( "C1", var_data((ssc_number_t)solver.C1) ); assign( "C2", var_data((ssc_number_t)solver.C2) ); assign( "C3", var_data((ssc_number_t)solver.C3) ); assign( "D1", var_data((ssc_number_t)solver.D1) ); assign( "D2", var_data((ssc_number_t)solver.D2) ); assign( "D3", var_data((ssc_number_t)solver.D3) ); assign( "Egref", var_data((ssc_number_t)solver.Egref) ); ssc_number_t *output = allocate( "output", par.nrows(), par.ncols() ); size_t c = 0; for( size_t i=0;i<par.nrows();i++ ) for( size_t j=0;j<par.ncols();j++ ) output[c++] = (ssc_number_t)par(i, j); }
RoNetServerType roNetServerTypeFromString(const RoString &serverTypeString) { for (int type = as_integer(RoNetServerType::LOGIN); type < as_integer(RoNetServerType::COUNT); ++type) { RoNetServerTypeInfo& serverTypeInfo = RoNetServerTypeInfoFactory::Get(type); if (serverTypeInfo.fromString(serverTypeString)) { return serverTypeInfo.getType(); } } return RoNetServerType::NONE; }
RoString to_string(RoLoginStage stage) { switch (stage) { case RoLoginStage::NONE: return "NONE"; case RoLoginStage::LOGIN_PROMPT: return "LOGIN_PROMPT"; case RoLoginStage::LOGIN_SERVER_CONNECTING: return "LOGIN_SERVER_CONNECTING"; case RoLoginStage::LOGIN_SERVER_READY: return "LOGIN_SERVER_READY"; case RoLoginStage::LOGIN_REQUEST_SENT: return "LOGIN_REQUEST_SENT"; case RoLoginStage::LOGIN_SUCCEEDED: return "LOGIN_SUCCEEDED"; case RoLoginStage::LOGIN_FAILED: return "LOGIN_FAILED"; case RoLoginStage::LOGIN_CANCELLED: return "LOGIN_CANCELLED"; default: break; } std::stringstream error; error << "UNKNOWN LOGIN STAGE (" << as_integer(stage) << ")"; return error.str(); }
std::string roGetLoginStageString(RoLoginStage stage) { switch (stage) { case RoLoginStage::NONE: return roSTRINGIFY(NONE); case RoLoginStage::LOGIN_PROMPT: return roSTRINGIFY(LOGIN_PROMPT); case RoLoginStage::LOGIN_SERVER_CONNECTING: return roSTRINGIFY(LOGIN_SERVER_CONNECTING); case RoLoginStage::LOGIN_REQUEST_SENT: return roSTRINGIFY(LOGIN_REQUEST_SENT); case RoLoginStage::LOGIN_SERVER_READY: return roSTRINGIFY(LOGIN_SERVER_READY); case RoLoginStage::LOGIN_CANCELLED: return roSTRINGIFY(LOGIN_CANCELLED); case RoLoginStage::LOGIN_FAILED: return roSTRINGIFY(LOGIN_FAILED); case RoLoginStage::LOGIN_SUCCEEDED: return roSTRINGIFY(LOGIN_SUCCEEDED); } std::stringstream ss; ss << "UKNOWN (" << as_integer(stage) << ")"; return ss.str(); }
void base::freeself_kind(kind k) { switch (k) { case BASE: freeself_base(); break; case INTEGER: as_integer().freeself_integer(); break; case VECTOR: as_vector().freeself_vector(); break; case NUMBER_PARTITION: as_number_partition().freeself_number_partition(); break; case PERMUTATION: as_permutation().freeself_permutation(); break; case MATRIX: as_matrix().freeself_matrix(); break; case LONGINTEGER: as_longinteger().freeself_longinteger(); break; case MEMORY: as_memory().freeself_memory(); break; //case PERM_GROUP: as_perm_group().freeself_perm_group(); break; //case PERM_GROUP_STAB_CHAIN: as_perm_group_stab_chain().freeself_perm_group_stab_chain(); break; case UNIPOLY: as_unipoly().freeself_unipoly(); break; case SOLID: as_solid().freeself_solid(); break; case BITMATRIX: as_bitmatrix().freeself_bitmatrix(); break; //case PC_PRESENTATION: as_pc_presentation().freeself_pc_presentation(); break; //case PC_SUBGROUP: as_pc_subgroup().freeself_pc_subgroup(); break; //case GROUP_WORD: as_group_word().freeself_group_word(); break; //case GROUP_TABLE: as_group_table().freeself_group_table(); break; // case ACTION: as_action().freeself_action(); break; case GEOMETRY: as_geometry().freeself_geometry(); break; case HOLLERITH: as_hollerith().freeself_hollerith(); break; case GROUP_SELECTION: as_group_selection().freeself_group_selection(); break; case BT_KEY: as_bt_key().freeself_bt_key(); break; case DATABASE: as_database().freeself_database(); break; case BTREE: as_btree().freeself_btree(); break; case DESIGN_PARAMETER_SOURCE: as_design_parameter_source().freeself_design_parameter_source(); break; case DESIGN_PARAMETER: as_design_parameter().freeself_design_parameter(); break; default: cout << "base::freeself_kind(), unknown kind: k= " << kind_ascii(k) << "\n"; } }
TEST(ArrayBuilder, WithAllInMultipleTimes) { cpp_redis::builders::array_builder builder; std::string buffer = "4\r\n+simple_string\r"; builder << buffer; buffer += "\n-error\r\n:42\r\n"; builder << buffer; buffer += "$5\r\nhello\r\n"; builder << buffer; EXPECT_EQ(true, builder.reply_ready()); EXPECT_EQ("", buffer); auto reply = builder.get_reply(); EXPECT_TRUE(reply.is_array()); auto array = reply.as_array(); EXPECT_EQ(4U, array.size()); auto row_1 = array[0]; EXPECT_TRUE(row_1.is_simple_string()); EXPECT_EQ("simple_string", row_1.as_string()); auto row_2 = array[1]; EXPECT_TRUE(row_2.is_error()); EXPECT_EQ("error", row_2.as_string()); auto row_3 = array[2]; EXPECT_TRUE(row_3.is_integer()); EXPECT_EQ(42, row_3.as_integer()); auto row_4 = array[3]; EXPECT_TRUE(row_4.is_bulk_string()); EXPECT_EQ("hello", row_4.as_string()); }
bool Indiv::setField(const FieldValue t, const web::json::value & value) { switch (t) { case FieldValue::hasimage: this->m_hasimage = ((!value.is_null()) && value.is_boolean()) ? value.as_bool() : false; return true; case FieldValue::imagedata: { this->m_size = 0; this->m_data.reset(); if (value.is_array()) { const size_t n = value.size(); if (n > 0) { this->m_data.reset(new byte[n]); byte *pDest = this->m_data.get(); if (pDest != nullptr) { for (size_t i = 0; i < n; ++i) { byte b = (byte) 0; auto v = value.get(i); if ((!v.is_null()) && v.is_number()) { b = (byte) v.as_integer(); } pDest[i] = b; } // i this->m_size = n; } // pDest } // n } // array } return true; default: break; } // t return (DatasetChild::setField(t, value)); } // setField
int print_header( FILE* f, const char* file_name, BehaviorTreeContext ctx ) { Parameter* opts = get_options( ctx ); unsigned int header_hash = hashlittle( "ctc_h_header" ); unsigned int footer_hash = hashlittle( "ctc_h_footer" ); unsigned int symbol_hash = hashlittle( "ctc_h_symbol_prefix" ); unsigned int id_hash = hashlittle( "id" ); const char* header = get_string_from_parameter_list( opts, header_hash ); const char* footer = get_string_from_parameter_list( opts, footer_hash ); const char* symbol = get_string_from_parameter_list( opts, symbol_hash ); fprintf( f, "/*\n * This file is auto generated by ctc from %s.\n * Manual edits will be lost when regenerated.\n */\n\n", file_name ); if( header ) fprintf( f, "%s\n\n", header ); int count; NamedSymbol* ns = access_symbols( ctx, &count ); for( int i = 0; i < count; ++i ) { if( ns[i].m_Type == E_ST_ACTION ) { Parameter* p = find_by_hash( ns[i].m_Symbol.m_Action->m_Options, id_hash ); if( p && safe_to_convert( p, E_VART_INTEGER ) ) print_header_entry( f, symbol, ns[i].m_Symbol.m_Action->m_Id.m_Text, as_integer( *p ) ); else print_header_entry( f, symbol, ns[i].m_Symbol.m_Action->m_Id.m_Text, ns[i].m_Symbol.m_Action->m_Id.m_Hash ); } else if( ns[i].m_Type == E_ST_DECORATOR ) { Parameter* p = find_by_hash( ns[i].m_Symbol.m_Decorator->m_Options, id_hash ); if( p && safe_to_convert( p, E_VART_INTEGER ) ) print_header_entry( f, symbol, ns[i].m_Symbol.m_Decorator->m_Id.m_Text, as_integer( *p ) ); else print_header_entry( f, symbol, ns[i].m_Symbol.m_Decorator->m_Id.m_Text, ns[i].m_Symbol.m_Action->m_Id.m_Hash ); } } if( footer ) fprintf( f, "\n%s\n", footer ); return 0; }
INT& base::s_i_i() { if (s_kind() != INTEGER) { cout << "base::s_i_i() not an integer, objectkind="; printobjectkindln(cout); exit(1); } return as_integer().s_i(); }
RtmpParser::RtmpParser(const AMFValue &val) { auto videoCodec = val["videocodecid"]; auto audioCodec = val["audiocodecid"]; if (videoCodec.type() == AMF_STRING) { if (videoCodec.as_string() == "avc1") { //264 m_bHaveVideo = true; } else { InfoL << "不支持RTMP视频格式:" << videoCodec.as_string(); } }else if (videoCodec.type() != AMF_NULL){ if (videoCodec.as_integer() == 7) { //264 m_bHaveVideo = true; } else { InfoL << "不支持RTMP视频格式:" << videoCodec.as_integer(); } } if (audioCodec.type() == AMF_STRING) { if (audioCodec.as_string() == "mp4a") { //aac m_bHaveAudio = true; } else { InfoL << "不支持RTMP音频格式:" << audioCodec.as_string(); } }else if (audioCodec.type() != AMF_NULL) { if (audioCodec.as_integer() == 10) { //aac m_bHaveAudio = true; } else { InfoL << "不支持RTMP音频格式:" << audioCodec.as_integer(); } } if (!m_bHaveVideo && !m_bHaveAudio) { throw std::runtime_error("不支持该RTMP媒体格式"); } onCheckMedia(val); }
TEST(IntegerBuilder, NegativeNumber) { cpp_redis::builders::integer_builder builder; std::string buffer = "-1\r\n"; builder << buffer; EXPECT_EQ(true, builder.reply_ready()); EXPECT_EQ("", buffer); auto reply = builder.get_reply(); EXPECT_TRUE(reply.is_integer()); EXPECT_EQ(-1, reply.as_integer()); }
TEST(IntegerBuilder, WithAllInOneTime) { cpp_redis::builders::integer_builder builder; std::string buffer = "42\r\n"; builder << buffer; EXPECT_EQ(true, builder.reply_ready()); EXPECT_EQ("", buffer); auto reply = builder.get_reply(); EXPECT_TRUE(reply.is_integer()); EXPECT_EQ(42, reply.as_integer()); }
bool JSON::as_bool() const { switch (m_type) { case e_null: return false; case e_bool: return m_bool; case e_integer: return as_integer() != 0; case e_real: return as_real() != Real64(0); case e_string: return stringToNumber(m_string).as_bool(); case e_array: return arrayToNumber(m_array).as_bool(); case e_object: return objectToNumber(m_object).as_bool(); } return 0; }
void exec( ) throw( general_error ) { // get values double rating = (double) as_number("machine_rating"); double diameter = (double)as_number("rotor_diameter"); double hubHt = (double)as_number("hub_height"); int nTurb = as_integer("number_of_turbines"); double voltage = (double)as_number("interconnect_voltage"); double distInter = (double)as_number("distance_to_interconnect"); SiteTerrain terrain = (SiteTerrain) as_integer("site_terrain"); TurbineLayout layout = (TurbineLayout)as_integer("turbine_layout"); SoilCondition soil = (SoilCondition)as_integer("soil_condition"); double farmSize = cm_windbos::farmSize(rating, nTurb); int constructionTime = (int)as_number("construction_time"); double buildingSize = (double)as_number("om_building_size"); double temporary = (double)as_number("quantity_test_met_towers"); double permanent = (double)as_number("quantity_permanent_met_towers"); int weatherDelayDays = (int)as_number("weather_delay_days"); int craneBreakdowns = (int)as_number("crane_breakdowns"); int accessRoadEntrances = (int)as_number("access_road_entrances"); double tcc = (double)as_number("turbine_capital_cost"); double topMass = (double)as_number("tower_top_mass"); int deliveryAssistRequired = as_integer("delivery_assist_required"); int padMountTransformer = as_integer("pad_mount_transformer_required"); int newSwitchyardRequired = as_integer("new_switchyard_required"); double rockTrenchingLength = (double)as_number("rock_trenching_required"); double thermalBackfill = (double)as_number("mv_thermal_backfill"); double overheadCollector = (double)as_number("mv_overhead_collector"); double performanceBond = (double)as_number("performance_bond"); double contingency = (double)as_number("contingency"); double warranty = (double)as_number("warranty_management"); double useTax = (double)as_number("sales_and_use_tax"); double overhead = (double)as_number("overhead"); double profitMargin = (double)as_number("profit_margin"); double developmentFee = (double)as_number("development_fee"); double transportDist = (double)as_number("turbine_transportation"); // run model (execute functions) ssc_number_t output = totalCost(rating, diameter, hubHt, nTurb, voltage, distInter, terrain, layout, soil, farmSize, tcc, topMass, constructionTime, buildingSize, temporary, permanent, weatherDelayDays, craneBreakdowns, accessRoadEntrances, deliveryAssistRequired, padMountTransformer, newSwitchyardRequired, rockTrenchingLength, thermalBackfill, overheadCollector, performanceBond, contingency, warranty, useTax, overhead, profitMargin, developmentFee, transportDist); // assign outputs assign( "project_total_budgeted_cost", var_data(output) ); }
void exec( ) throw( general_error ) { size_t i, j, nrows, ncols; // rated output ac double Paco = as_double("inv_cec_cg_paco"); bool kW_units = (as_integer("inv_cec_cg_sample_power_units") == 1); // 6 columns period, tier, max usage, max usage units, buy, sell ssc_number_t *inv_cec_cg_test_samples_in = as_matrix("inv_cec_cg_test_samples", &nrows, &ncols); if (nrows != 18) { std::ostringstream ss; ss << "The samples table must have 18 rows. Number of rows in samples table provided is " << nrows << " rows."; throw exec_error("inv_cec_cg", ss.str()); } if ((ncols % 3) != 0) { std::ostringstream ss; ss << "The samples table must have number of columns divisible by 3. Number of columns in samples table provided is " << ncols << " columns."; throw exec_error("inv_cec_cg", ss.str()); } size_t num_samples = ncols / 3; size_t columns_per_sample = 3; util::matrix_t<float> inv_cec_cg_test_samples(nrows, ncols); inv_cec_cg_test_samples.assign(inv_cec_cg_test_samples_in, nrows, ncols); ssc_number_t vdc = 0, Pout = 0, eff = 0, Pin=0, Pin2=0; // set Pout, Pin=Pout/eff and Pin^2 for least squares fit // 6 is for the required power output percentages at each voltage for each sample util::matrix_t<ssc_number_t> &inv_cec_cg_Vmin = allocate_matrix("inv_cec_cg_Vmin", 6 * num_samples, 3); util::matrix_t<ssc_number_t> &inv_cec_cg_Vnom = allocate_matrix("inv_cec_cg_Vnom", 6 * num_samples, 3); util::matrix_t<ssc_number_t> &inv_cec_cg_Vmax = allocate_matrix("inv_cec_cg_Vmax", 6 * num_samples, 3); ssc_number_t *inv_cec_cg_Vdc = allocate("inv_cec_cg_Vdc", 3); ssc_number_t *inv_cec_cg_Vdc_Vnom = allocate("inv_cec_cg_Vdc_Vnom", 3); ssc_number_t *inv_cec_cg_Pdco = allocate("inv_cec_cg_Pdco", 3); ssc_number_t *inv_cec_cg_Psco = allocate("inv_cec_cg_Psco", 3); ssc_number_t *inv_cec_cg_C0 = allocate("inv_cec_cg_C0", 3); ssc_number_t *inv_cec_cg_C1 = allocate("inv_cec_cg_C1", 2); ssc_number_t *inv_cec_cg_C2 = allocate("inv_cec_cg_C2", 2); ssc_number_t *inv_cec_cg_C3 = allocate("inv_cec_cg_C3", 2); for (i = 0; i < 3; i++) inv_cec_cg_Vdc[i] = 0; for (j = 0; j < num_samples; j++) { for (i = 0; i < inv_cec_cg_test_samples.nrows(); i++) { vdc = inv_cec_cg_test_samples.at(i, j*columns_per_sample + 1); Pout = inv_cec_cg_test_samples.at(i, j*columns_per_sample); if (kW_units) Pout *= 1000; // kW to W eff = inv_cec_cg_test_samples.at(i, j*columns_per_sample+2); Pin = Pout; if (eff != 0.0f) Pin = (ssc_number_t)(100.0*Pout) / eff; Pin2 = Pin*Pin; if (i < 6) // Vmin 0 offset { inv_cec_cg_Vdc[0] += vdc; inv_cec_cg_Vmin.at(j * 6 + i, 0) = Pout; inv_cec_cg_Vmin.at(j * 6 + i, 1) = Pin; inv_cec_cg_Vmin.at(j * 6 + i, 2) = Pin2; } else if (i < 12) // Vnom 6 offset { inv_cec_cg_Vdc[1] += vdc; inv_cec_cg_Vnom.at(j * 6 + i - 6, 0) = Pout; inv_cec_cg_Vnom.at(j * 6 + i-6, 1) = Pin; inv_cec_cg_Vnom.at(j * 6 + i-6, 2) = Pin2; } else // Vmax 12 offset { inv_cec_cg_Vdc[2] += vdc; inv_cec_cg_Vmax.at(j * 6 + i - 12, 0) = Pout; inv_cec_cg_Vmax.at(j * 6 + i - 12, 1) = Pin; inv_cec_cg_Vmax.at(j * 6 + i - 12, 2) = Pin2; } } } ssc_number_t *inv_cec_cg_Vmin_abc = allocate("inv_cec_cg_Vmin_abc", 3); ssc_number_t *inv_cec_cg_Vnom_abc = allocate("inv_cec_cg_Vnom_abc", 3); ssc_number_t *inv_cec_cg_Vmax_abc = allocate("inv_cec_cg_Vmax_abc", 3); std::vector<double> Pout_vec(inv_cec_cg_Vmin.nrows()); std::vector<double> Pin_vec(inv_cec_cg_Vmin.nrows()); int info; double C[3];// initial guesses for lsqfit size_t data_size = 3; // Vmin non-linear for (i = 0; i < inv_cec_cg_Vmin.nrows(); i++) { Pin_vec[i] = inv_cec_cg_Vmin.at(i, 1); Pout_vec[i] = inv_cec_cg_Vmin.at(i, 0); } C[0] = -1e-6; C[1] = 1; C[2] = 1e3; if (!(info=lsqfit(Quadratic_fit_eqn, 0, C, data_size, &Pin_vec[0], &Pout_vec[0], inv_cec_cg_Vmin.nrows()))) { throw exec_error("inv_cec_cg", util::format("error in nonlinear least squares fit, error %d", info)); return; } inv_cec_cg_Vmin_abc[0] = (ssc_number_t)C[0]; inv_cec_cg_Vmin_abc[1] = (ssc_number_t)C[1]; inv_cec_cg_Vmin_abc[2] = (ssc_number_t)C[2]; // Vnom non-linear for (i = 0; i < inv_cec_cg_Vnom.nrows(); i++) { Pin_vec[i] = inv_cec_cg_Vnom.at(i, 1); Pout_vec[i] = inv_cec_cg_Vnom.at(i, 0); } C[0] = -1e-6; C[1] = 1; C[2] = 1e3; if (!(info = lsqfit(Quadratic_fit_eqn, 0, C, data_size, &Pin_vec[0], &Pout_vec[0], inv_cec_cg_Vnom.nrows()))) { throw exec_error("inv_cec_cg", util::format("error in nonlinear least squares fit, error %d", info)); return; } inv_cec_cg_Vnom_abc[0] = (ssc_number_t)C[0]; inv_cec_cg_Vnom_abc[1] = (ssc_number_t)C[1]; inv_cec_cg_Vnom_abc[2] = (ssc_number_t)C[2]; // Vmax non-linear for (i = 0; i < inv_cec_cg_Vmax.nrows(); i++) { Pin_vec[i] = inv_cec_cg_Vmax.at(i, 1); Pout_vec[i] = inv_cec_cg_Vmax.at(i, 0); } C[0] = -1e-6; C[1] = 1; C[2] = 1e3; if (!(info = lsqfit(Quadratic_fit_eqn, 0, C, data_size, &Pin_vec[0], &Pout_vec[0], inv_cec_cg_Vmax.nrows()))) { throw exec_error("inv_cec_cg", util::format("error in nonlinear least squares fit, error %d", info)); return; } inv_cec_cg_Vmax_abc[0] = (ssc_number_t)C[0]; inv_cec_cg_Vmax_abc[1] = (ssc_number_t)C[1]; inv_cec_cg_Vmax_abc[2] = (ssc_number_t)C[2]; // Fill in intermediate values //Vdc (Vmin, Vnom, Vmax) for (i = 0; i < 3;i++) inv_cec_cg_Vdc[i] /= (6 * num_samples); // Vdc-Vnom for (i = 0; i < 3; i++) inv_cec_cg_Vdc_Vnom[i] = inv_cec_cg_Vdc[i] - inv_cec_cg_Vdc[1]; ssc_number_t a, b, c; // Pdco and Psco and C0 a = inv_cec_cg_Vmin_abc[0]; b = inv_cec_cg_Vmin_abc[1]; c = inv_cec_cg_Vmin_abc[2]; inv_cec_cg_Pdco[0] = (ssc_number_t)(-b + sqrt(b*b - 4 * a*(c - Paco))); inv_cec_cg_Psco[0] = (-b + sqrt(b*b - 4 * a*c)); inv_cec_cg_C0[0] = a; if (a != 0) { inv_cec_cg_Pdco[0] /= (ssc_number_t)(2.0*a); inv_cec_cg_Psco[0] /= (ssc_number_t)(2.0*a); } a = inv_cec_cg_Vnom_abc[0]; b = inv_cec_cg_Vnom_abc[1]; c = inv_cec_cg_Vnom_abc[2]; inv_cec_cg_Pdco[1] = (ssc_number_t)(-b + sqrt(b*b - 4 * a*(c - Paco))); inv_cec_cg_Psco[1] = (-b + sqrt(b*b - 4 * a*c)); inv_cec_cg_C0[1] = a; if (a != 0) { inv_cec_cg_Pdco[1] /= (ssc_number_t)(2.0*a); inv_cec_cg_Psco[1] /= (ssc_number_t)(2.0*a); } // TODO - limit Psco max to not be less than zero per note in Workbook a = inv_cec_cg_Vmax_abc[0]; b = inv_cec_cg_Vmax_abc[1]; c = inv_cec_cg_Vmax_abc[2]; inv_cec_cg_Pdco[2] = (ssc_number_t)(-b + sqrt(b*b - 4 * a*(c - Paco))); inv_cec_cg_Psco[2] = (-b + sqrt(b*b - 4 * a*c)); inv_cec_cg_C0[2] = a; if (a != 0) { inv_cec_cg_Pdco[2] /= (ssc_number_t)(2.0*a); inv_cec_cg_Psco[2] /= (ssc_number_t)(2.0*a); } // C1, C2, C3 linear least squares // C1 Y=Pdco, X=Vdc-Vnom std::vector<double> X(3); std::vector<double> Y(3); double slope, intercept; // C1 using linear least squares fit for (i = 0; i < 3; i++) { X[i] = inv_cec_cg_Vdc_Vnom[i]; Y[i] = inv_cec_cg_Pdco[i]; } if ((info = linlsqfit(&slope, &intercept, &X[0], &Y[0], data_size))) { throw exec_error("inv_cec_cg", util::format("error in linear least squares fit, error %d", info)); return; } inv_cec_cg_C1[0] = (ssc_number_t)slope; inv_cec_cg_C1[1] = (ssc_number_t)intercept; // C2 using linear least squares fit for (i = 0; i < 3; i++) { X[i] = inv_cec_cg_Vdc_Vnom[i]; Y[i] = inv_cec_cg_Psco[i]; } if ((info = linlsqfit(&slope, &intercept, &X[0], &Y[0], data_size))) { throw exec_error("inv_cec_cg", util::format("error in linear least squares fit, error %d", info)); return; } inv_cec_cg_C2[0] = (ssc_number_t)slope; inv_cec_cg_C2[1] = (ssc_number_t)intercept; // C2 using linear least squares fit for (i = 0; i < 3; i++) { X[i] = inv_cec_cg_Vdc_Vnom[i]; Y[i] = inv_cec_cg_C0[i]; } if ((info = linlsqfit(&slope, &intercept, &X[0], &Y[0], data_size))) { throw exec_error("inv_cec_cg", util::format("error in linear least squares fit, error %d", info)); return; } inv_cec_cg_C3[0] = (ssc_number_t)slope; inv_cec_cg_C3[1] = (ssc_number_t)intercept; // vdco is the average of Vnom of all samples column 2 and rows 7 through 12 assign("Pdco", (var_data)inv_cec_cg_C1[1]); assign("Vdco", (var_data)inv_cec_cg_Vdc[1]); assign("Pso", (var_data)inv_cec_cg_C2[1]); assign("c0", (var_data)inv_cec_cg_C3[1]); assign("c1", (var_data)(inv_cec_cg_C1[0] / inv_cec_cg_C1[1])); assign("c2", (var_data)(inv_cec_cg_C2[0] / inv_cec_cg_C2[1])); assign("c3", (var_data)(inv_cec_cg_C3[0] / inv_cec_cg_C3[1])); }
int main(){ std::clog << as_integer(RestCode::ADD_CPU_ERROR); std::clog << quote(ADD_CPU_ERROR); return 0; }
flags(enumeration_type const value) : _value(as_integer(value)) { }
const char* list_as_string( BehaviorTreeContext tree, Parameter* v ) { const char* ret = ""; int space = 0; int written = 0; char* str = 0x0; char* s; while( v ) { char tmp[1024]; int n = sprintf( tmp, "%s = ", v->m_Id.m_Text ); if( space - (n + written + 1) < 0 ) { space = max( space * 2, n + written + 1 ); str = (char*)realloc( str, space ); } s = str + written; memcpy( s, tmp, n + 1 ); written += n; switch( v->m_Type ) { case E_VART_INTEGER: n = sprintf( tmp, "%d", as_integer( *v ) ); break; case E_VART_FLOAT: n = sprintf( tmp, "%f", as_float( *v ) ); break; case E_VART_STRING: n = sprintf( tmp, "\"%s\"", as_string( *v )->m_Parsed ); break; case E_VART_BOOL: n = sprintf( tmp, "%s", as_bool( *v ) ? "true" : "false" ); break; case E_VART_HASH: n = sprintf( tmp, "0x%08x", as_hash( *v ) ); break; case E_VART_UNDEFINED: case E_MAX_VARIABLE_TYPE: break; } v = v->m_Next; if( v ) { tmp[++n] = ','; tmp[++n] = ' '; tmp[n + 1] = 0; } if( space - (n + written + 1) < 0 ) { space = max( space * 2, n + written + 1 ); str = (char*)realloc( str, space ); } s = str + written; memcpy( s, tmp, n + 1 ); written += n; } if( str ) { if( tree ) ret = register_string( tree, str ); free( str ); str = 0x0; } return ret; }
void exec( ) throw( general_error ) { size_t arr_len; ssc_number_t *p_poabeam = as_array( "poa_beam", &arr_len ); ssc_number_t *p_poaskydiff = as_array( "poa_skydiff", &arr_len ); ssc_number_t *p_poagnddiff = as_array( "poa_gnddiff", &arr_len ); ssc_number_t *p_tdry = as_array( "tdry", &arr_len ); ssc_number_t *p_wspd = as_array( "wspd", &arr_len ); ssc_number_t *p_wdir = as_array( "wdir", &arr_len ); ssc_number_t *p_inc = as_array( "incidence", &arr_len ); ssc_number_t *p_zen = as_array( "sun_zen", &arr_len ); ssc_number_t *p_stilt = as_array( "surf_tilt", &arr_len ); double site_elevation = as_double("elev"); cec6par_module_t mod; mod.Area = as_double("area"); mod.Vmp = as_double("Vmp"); mod.Imp = as_double("Imp"); mod.Voc = as_double("Voc"); mod.Isc = as_double("Isc"); mod.alpha_isc = as_double("alpha_isc"); mod.beta_voc = as_double("beta_voc"); mod.a = as_double("a"); mod.Il = as_double("Il"); mod.Io = as_double("Io"); mod.Rs = as_double("Rs"); mod.Rsh = as_double("Rsh"); mod.Adj = as_double("Adj"); noct_celltemp_t tc; tc.Tnoct = as_double("tnoct"); int standoff = as_integer("standoff"); tc.standoff_tnoct_adj = 0; switch(standoff) { case 2: tc.standoff_tnoct_adj = 2; break; // between 2.5 and 3.5 inches case 3: tc.standoff_tnoct_adj = 6; break; // between 1.5 and 2.5 inches case 4: tc.standoff_tnoct_adj = 11; break; // between 0.5 and 1.5 inches case 5: tc.standoff_tnoct_adj = 18; break; // less than 0.5 inches // note: all others, standoff_tnoct_adj = 0; } int height = as_integer("height"); tc.ffv_wind = 0.51; if ( height == 1 ) tc.ffv_wind = 0.61; ssc_number_t *opvoltage = 0; if ( is_assigned("opvoltage") ) { size_t opvlen = 0; opvoltage = as_array( "opvoltage", &opvlen ); if ( opvlen != arr_len ) throw general_error("operating voltage array must be same length as input vectors"); } ssc_number_t *p_tcell = allocate("tcell", arr_len); ssc_number_t *p_volt = allocate("dc_voltage", arr_len); ssc_number_t *p_amp = allocate("dc_current", arr_len); ssc_number_t *p_eff = allocate("eff", arr_len); ssc_number_t *p_dc = allocate("dc", arr_len); for (size_t i = 0; i < arr_len; i++ ) { pvinput_t in; in.Ibeam = (double) p_poabeam[i]; in.Idiff = (double) p_poaskydiff[i]; in.Ignd = (double) p_poagnddiff[i]; in.Tdry = (double) p_tdry[i]; in.Wspd = (double) p_wspd[i]; in.Wdir = (double) p_wdir[i]; in.Zenith = (double) p_zen[i]; in.IncAng = (double) p_inc[i]; in.Elev = site_elevation; in.Tilt = (double) p_stilt[i]; pvoutput_t out; double opv = -1; // by default, calculate MPPT if ( opvoltage != 0 ) opv = opvoltage[i]; double tcell = in.Tdry; if (! tc( in, mod, opv, tcell ) ) throw general_error("error calculating cell temperature", (float)i); if (! mod( in, tcell, opv, out ) ) throw general_error( "error calculating module power and temperature with given parameters", (float) i); p_tcell[i] = (ssc_number_t)out.CellTemp; p_volt[i] = (ssc_number_t)out.Voltage; p_amp[i] = (ssc_number_t)out.Current; p_eff[i] = (ssc_number_t)out.Efficiency; p_dc[i] = (ssc_number_t)out.Power; } }
size_t operator()(const vg::handle_t& handle) const { return wang_hash<std::int64_t>()(as_integer(handle)); }
TEST_FIXTURE( VariableTypeFloatFixture, FloatConvertToIntegerReturnsCorrectValue ) { v.m_Data.m_Float = 17.002f; CHECK( 17 == as_integer( v ) ); }
TEST_FIXTURE( VariableTypeIntegerFixture, IntegerToIntegerConversionDoesNotReturnIncorrectValue ) { v.m_Data.m_Integer = 357; CHECK( 4723 != as_integer( v ) ); }
int main( int argc, char** argv ) { GetOptContext ctx; init_getopt_context( &ctx ); char c; while( (c = getopt( argc, argv, "?i:o:a:de:x:lrh:v", &ctx )) != -1 ) { switch( c ) { case 'i': g_inputFileName = ctx.optarg; break; case 'o': g_outputFileName = ctx.optarg; break; case 'e': if( strcmp( ctx.optarg, "big" ) == 0 ) g_swapEndian = true; else if( strcmp( ctx.optarg, "little" ) == 0 ) g_swapEndian = false; else { fprintf( stderr, "error: unknown argument for option -e: %s\n", ctx.optarg ); return -1; } break; case 'a': g_asmFileName = ctx.optarg; break; case 'l': g_printIncludes = true; break; case 'v': /* verbose, print extra funny stuff! */ break; case 'h': g_outputHeaderName = ctx.optarg; break; case ':': print_usage(); return -1; break; case '?': print_usage(); return 0; break; } } if(ctx.optind != argc) { fprintf( stdout, "%s: unexpected argument '%s'\n", argv[0], argv[ctx.optind] ); print_usage(); return -1; } int returnCode = 0; if( !g_inputFileName ) { returnCode = -1; fprintf( stderr, "error: No input file given.\n" ); } // Convert all \ to / in the input file name, in order to // aid the include path translation for( char* p = g_inputFileName; p && *p; ++p ) { if( *p == '\\' ) *p = '/'; } if( returnCode == 0 ) { Allocator a; a.m_Alloc = &allocate_memory; a.m_Free = &free_memory; BehaviorTreeContext btc = create_bt_context( a ); ParserContextFunctions pcf; pcf.m_Read = &read_file; pcf.m_Error = &parser_error; pcf.m_Warning = &parser_warning; pcf.m_Translate = &parser_translate_include; ParsingInfo pi; pi.m_Name = g_inputFileName; pi.m_File = fopen( pi.m_Name, "r" ); if( !pi.m_File ) { fprintf( stderr, "%s(0): error: unable to open input file \"%s\" for reading.\n", g_inputFileName, pi.m_Name ); returnCode = -1; } if( returnCode == 0 ) { ParserContext pc = create_parser_context( btc ); set_extra( pc, &pi ); set_current( pc, pi.m_Name ); returnCode = parse( pc, &pcf ); destroy( pc ); } if( pi.m_File ) fclose( pi.m_File ); Include* include = get_first_include( btc ); while( returnCode == 0 && include ) { pi.m_Name = include->m_Name; pi.m_File = fopen( pi.m_Name, "r" ); if( !pi.m_File ) { fprintf( stderr, "%s(%d): error: unable to open include file \"%s\" for reading.\n", include->m_Parent, include->m_LineNo, pi.m_Name ); returnCode = -1; break; } ParserContext pc = create_parser_context( btc ); set_extra( pc, &pi ); set_current( pc, pi.m_Name ); returnCode = parse( pc, &pcf ); destroy( pc ); if( pi.m_File ) fclose( pi.m_File ); if( returnCode != 0 ) break; include = include->m_Next; } include = get_first_include( btc ); while( returnCode == 0 && include && g_printIncludes ) { printf( "%s\n", include->m_Name ); include = include->m_Next; } if( g_outputHeaderName && returnCode == 0 ) { FILE* header = fopen( g_outputHeaderName, "w" ); if( !header ) { fprintf( stderr, "%s(0): error: Unable to open output file %s for writing.\n", g_inputFileName, g_outputHeaderName ); returnCode = -1; } else { returnCode = print_header( header, g_inputFileName, btc ); if( returnCode != 0 ) fprintf( stderr, "%s(0): error: unspecified error when writing header %s.\n", g_inputFileName, g_outputHeaderName ); fclose( header ); } } if( g_outputFileName && returnCode == 0 ) { Program p; unsigned int debug_hash = hashlittle( "debug_info" ); Parameter* debug_param = find_by_hash( get_options( btc ), debug_hash ); if( debug_param ) p.m_I.SetGenerateDebugInfo( as_integer( *debug_param ) ); returnCode = setup( btc, &p ); if( returnCode == 0 ) { returnCode = generate( &p ); if( returnCode != 0 ) fprintf( stderr, "%s(0): error: Internal compiler error in generate.\n", g_inputFileName ); } else { fprintf( stderr, "%s(0): error: Internal compiler error in setup.\n", g_inputFileName ); } teardown( &p ); if( returnCode == 0 ) { g_outputFile = fopen( g_outputFileName, "wb" ); if( !g_outputFile ) { fprintf( stderr, "%s(0): error: Unable to open output file %s for writing.\n", g_inputFileName, g_outputFileName ); returnCode = -2; } if( returnCode == 0 ) returnCode = save_program( g_outputFile, g_swapEndian, &p ); if( returnCode != 0 ) { fprintf( stderr, "%s(0): error: Failed to write output file %s.\n", g_inputFileName, g_outputFileName ); returnCode = -5; } } if( !g_asmFileName ) { unsigned int hash = hashlittle( "force_asm" ); Parameter* force_asm = find_by_hash( get_options( btc ), hash ); if( force_asm && as_bool( *force_asm ) ) { unsigned int len = strlen( g_outputFileName ); g_asmFileNameMemory = (char*)malloc( len + 5 ); memcpy( g_asmFileNameMemory, g_outputFileName, len ); g_asmFileNameMemory[len + 0] = '.'; g_asmFileNameMemory[len + 1] = 'a'; g_asmFileNameMemory[len + 2] = 's'; g_asmFileNameMemory[len + 3] = 'm'; g_asmFileNameMemory[len + 4] = 0; g_asmFileName = g_asmFileNameMemory; } } if( returnCode == 0 && g_asmFileName ) { FILE* asmFile = fopen( g_asmFileName, "w" ); if( !asmFile ) { fprintf( stderr, "%s(0): error: Unable to open assembly file %s for writing.\n", g_inputFileName, g_asmFileName ); returnCode = -1; } else { print_program( asmFile, &p ); fclose( asmFile ); } } } destroy( btc ); } if( g_asmFileNameMemory ) free( g_asmFileNameMemory ); if( g_outputFile ) fclose( g_outputFile ); return returnCode; }
TEST_FIXTURE( VariableTypeStringFixture, StringConvertsToZeroInteger ) { CHECK( 0 == as_integer( v ) ); }
TEST_FIXTURE( VariableTypeIntegerFixture, IntegerToIntegerConversionReturnsCorrectValue ) { v.m_Data.m_Integer = 357; CHECK( 357 == as_integer( v ) ); }
/// Define inequality on path handles inline bool operator!=(const path_handle_t& a, const path_handle_t& b) { return as_integer(a) != as_integer(b); }
TEST_FIXTURE( VariableTypeBoolFixture, BoolConvertsCorrectlyToInteger ) { CHECK( 0xffffffff == as_integer( v ) ); }