// Using rules, CPT and binding to predict cases, return prediction results. Pred predict(const vector<Constraint>& cons, const vector<CPTRow>& cpt, const vector<string>& plst, const vector<string>& nlst) { Pred resu; resu.TP = -1; resu.FP = -1; resu.TN = -1; resu.FN = -1; int TP = 0; for(size_t i = 0; i < plst.size(); i++) { string gene = plst[i]; int idx = classification(gene, cons); if(cpt[idx].k0 <= cpt[idx].k1) TP++; } resu.TP = TP; resu.FN = (int)plst.size() - TP; int TN = 0; for(size_t i = 0; i < nlst.size(); i++) { string gene = nlst[i]; int idx = classification(gene, cons); if(cpt[idx].k0 > cpt[idx].k1) TN++; } resu.TN = TN; resu.FP = (int)nlst.size() - TN; return resu; }
int naiveBayes(Data_t *dataset, int lweight, int ldistance, int rweight, int rdistance, Results_t *results, int datacount) { int ret = SUCCEED; Data_t values = { FAIL, lweight, ldistance, rweight, rdistance}; results->left = classification(dataset, CLASSNAME, LEFT, values, datacount); results->balance = classification(dataset, CLASSNAME, BALANCE, values, datacount); results->right = classification(dataset, CLASSNAME, RIGHT, values, datacount); return ret; }
CStdString PDFDocumentTagger::GetClassification() { CDIntfEx::IDIDocumentPtr spDocument; HRESULT hr = spDocument.CreateInstance(__uuidof(CDIntfEx::Document)); if(S_OK != hr) throw Workshare::Com::ComException(_T("Unable to create instance of PDF Document"), hr); VARIANT_BOOL bOpen = spDocument->Open(m_fileName.c_str()); if(VARIANT_FALSE == bOpen) { CStdString sError; sError.Format(_T("Failed to open PDF document %s"), m_fileName.c_str()); throw Workshare::System::SystemException(sError); } CStdString classificationTag(c_sNoClassification); try { PDFPropertyHandler pph(spDocument->KeyWords); classificationTag = pph.GetProperty(c_sWSClassification); } catch(...) { return c_sNoClassification; } CStdString classification(classificationTag); int nEqualsPos = classification.Find('='); if (nEqualsPos == -1) return c_sNoClassification; return classification.Mid(nEqualsPos + 1); }
// Operator overload for different parameter. vector<BPred> predict(const vector<Constraint>& cons, const vector<CPTRow>& cpt, const vector<Case>& genlst, int label) { vector<BPred> vbpred; for(size_t i = 0; i < genlst.size(); i++) { BPred bpred; string gene = genlst[i].name; int idx = classification(gene, cons); bpred.prob = (double)cpt[idx].k1/(cpt[idx].k0+cpt[idx].k1); bpred.label = label; bpred.name = gene; vbpred.push_back(bpred); } return vbpred; }
/* Pour attendre l'utilisateur tapper des commandes Cette methode va traitter des commandes entrées pour réaliser des besoin en rappant des autres méthodes correspondantes */ void Control::processCommand(int argc, char* argv[]) { std::string command, image_name; if(argc < 2) return; command = std::string(argv[1]); if(command.compare(CMD_HIST) == 0) { image_name = std::string(argv[2]); this->drawHistogram(image_name); } if(command.compare(CMD_CLASS) == 0) { std::string csv_train = std::string(argv[2]); std::string csv_test = std::string(argv[3]); classification(csv_train, csv_test); } }
void Node::parseAll() { n(); dn(); d2n(); i(); Omega(); omega(); M(); e(); bstar(); satelliteNumber(); satelliteName(); designator(); classification(); ephemerisType(); elementNumber(); revolutionNumber(); preciseEpoch(); }
// Construct conditional probability table given gene list, constraints and motif binding. void constrcpt(vector<CPTRow>& cpt, vector<CPTRow>& ppt, const vector<Case>& genlst, const vector<Constraint>& cons) { if(cons.size() < 1) { cpt.clear(); return; } // Set prior CPT. setprior(ppt, cons); // Initialize the CPT. initcpt(cpt, (size_t)pow((double)2, (int)cons.size())); // Classify each gene and increase the corresponding CPT entry by one. for(size_t i = 0; i < genlst.size(); i++) { int tidx = classification(genlst[i].name, cons); if(genlst[i].label == 0) cpt[tidx].k0++; else if(genlst[i].label == 1) cpt[tidx].k1++; } }
std::string Node::secondString() const { std::string res = "1 "; res += string2string(satelliteNumber(), 5); const char cl = classification(); res += (isprint(cl) ? std::string(1, cl) : " ") + " "; res += string2string(designator(), 8) + " "; res += date2string(preciseEpoch(), 14) + " "; res += double2string(dn(), 10, 8, false, false, false) + " "; res += double2string(d2n(), 8, 3, true, true, false) + " "; res += double2string(bstar(), 8, 3, true, true, false) + " "; const char eph = ephemerisType(); res += (isprint(eph) ? std::string(1, eph) : " ") + " "; res += int2string(elementNumber(), 4, false); // Checksum int sum = checksum(res); res += int2string(sum, 1); return res; }
Wt::WString User::classification_str() const { return classification2str(classification()); }
int main(int argc, char *argv[]) { /* Variables' declarations */ int nsplx_adj, nsply_adj; int nsubregion_col, nsubregion_row, subregion = 0, nsubregions = 0; double N_extension, E_extension, edgeE, edgeN; int dim_vect, nparameters, BW, npoints; double lambda_B, lambda_F, grad_H, grad_L, alpha, mean; const char *dvr, *db, *mapset; char table_interpolation[GNAME_MAX], table_name[GNAME_MAX]; char xname[GNAME_MAX], xmapset[GMAPSET_MAX]; int last_row, last_column, flag_auxiliar = FALSE; int *lineVect; double *TN, *Q, *parVect_bilin, *parVect_bicub; /* Interpolating and least-square vectors */ double **N, **obsVect; /* Interpolation and least-square matrix */ /* Structs' declarations */ struct Map_info In, Out; struct Option *in_opt, *out_opt, *stepE_opt, *stepN_opt, *lambdaF_opt, *lambdaB_opt, *gradH_opt, *gradL_opt, *alfa_opt; struct Flag *spline_step_flag; struct GModule *module; struct Cell_head elaboration_reg, original_reg; struct Reg_dimens dims; struct bound_box general_box, overlap_box; struct Point *observ; dbDriver *driver; /*------------------------------------------------------------------------------------------*/ /* Options' declaration */ module = G_define_module(); G_add_keyword(_("vector")); G_add_keyword(_("LIDAR")); G_add_keyword(_("edges")); module->description = _("Detects the object's edges from a LIDAR data set."); spline_step_flag = G_define_flag(); spline_step_flag->key = 'e'; spline_step_flag->label = _("Estimate point density and distance"); spline_step_flag->description = _("Estimate point density and distance for the input vector points within the current region extends and quit"); in_opt = G_define_standard_option(G_OPT_V_INPUT); out_opt = G_define_standard_option(G_OPT_V_OUTPUT); stepE_opt = G_define_option(); stepE_opt->key = "see"; stepE_opt->type = TYPE_DOUBLE; stepE_opt->required = NO; stepE_opt->answer = "4"; stepE_opt->description = _("Interpolation spline step value in east direction"); stepE_opt->guisection = _("Settings"); stepN_opt = G_define_option(); stepN_opt->key = "sen"; stepN_opt->type = TYPE_DOUBLE; stepN_opt->required = NO; stepN_opt->answer = "4"; stepN_opt->description = _("Interpolation spline step value in north direction"); stepN_opt->guisection = _("Settings"); lambdaB_opt = G_define_option(); lambdaB_opt->key = "lambda_g"; lambdaB_opt->type = TYPE_DOUBLE; lambdaB_opt->required = NO; lambdaB_opt->description = _("Regularization weight in gradient evaluation"); lambdaB_opt->answer = "0.01"; lambdaB_opt->guisection = _("Settings"); gradH_opt = G_define_option(); gradH_opt->key = "tgh"; gradH_opt->type = TYPE_DOUBLE; gradH_opt->required = NO; gradH_opt->description = _("High gradient threshold for edge classification"); gradH_opt->answer = "6"; gradH_opt->guisection = _("Settings"); gradL_opt = G_define_option(); gradL_opt->key = "tgl"; gradL_opt->type = TYPE_DOUBLE; gradL_opt->required = NO; gradL_opt->description = _("Low gradient threshold for edge classification"); gradL_opt->answer = "3"; gradL_opt->guisection = _("Settings"); alfa_opt = G_define_option(); alfa_opt->key = "theta_g"; alfa_opt->type = TYPE_DOUBLE; alfa_opt->required = NO; alfa_opt->description = _("Angle range for same direction detection"); alfa_opt->answer = "0.26"; alfa_opt->guisection = _("Settings"); lambdaF_opt = G_define_option(); lambdaF_opt->key = "lambda_r"; lambdaF_opt->type = TYPE_DOUBLE; lambdaF_opt->required = NO; lambdaF_opt->description = _("Regularization weight in residual evaluation"); lambdaF_opt->answer = "2"; lambdaF_opt->guisection = _("Settings"); /* Parsing */ G_gisinit(argv[0]); if (G_parser(argc, argv)) exit(EXIT_FAILURE); line_out_counter = 1; stepN = atof(stepN_opt->answer); stepE = atof(stepE_opt->answer); lambda_F = atof(lambdaF_opt->answer); lambda_B = atof(lambdaB_opt->answer); grad_H = atof(gradH_opt->answer); grad_L = atof(gradL_opt->answer); alpha = atof(alfa_opt->answer); grad_L = grad_L * grad_L; grad_H = grad_H * grad_H; if (!(db = G__getenv2("DB_DATABASE", G_VAR_MAPSET))) G_fatal_error(_("Unable to read name of database")); if (!(dvr = G__getenv2("DB_DRIVER", G_VAR_MAPSET))) G_fatal_error(_("Unable to read name of driver")); /* Setting auxiliar table's name */ if (G_name_is_fully_qualified(out_opt->answer, xname, xmapset)) { sprintf(table_name, "%s_aux", xname); sprintf(table_interpolation, "%s_edge_Interpolation", xname); } else { sprintf(table_name, "%s_aux", out_opt->answer); sprintf(table_interpolation, "%s_edge_Interpolation", out_opt->answer); } /* Something went wrong in a previous v.lidar.edgedetection execution */ if (db_table_exists(dvr, db, table_name)) { /* Start driver and open db */ driver = db_start_driver_open_database(dvr, db); if (driver == NULL) G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."), dvr); if (P_Drop_Aux_Table(driver, table_name) != DB_OK) G_fatal_error(_("Old auxiliar table could not be dropped")); db_close_database_shutdown_driver(driver); } /* Something went wrong in a previous v.lidar.edgedetection execution */ if (db_table_exists(dvr, db, table_interpolation)) { /* Start driver and open db */ driver = db_start_driver_open_database(dvr, db); if (driver == NULL) G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."), dvr); if (P_Drop_Aux_Table(driver, table_interpolation) != DB_OK) G_fatal_error(_("Old auxiliar table could not be dropped")); db_close_database_shutdown_driver(driver); } /* Checking vector names */ Vect_check_input_output_name(in_opt->answer, out_opt->answer, G_FATAL_EXIT); if ((mapset = G_find_vector2(in_opt->answer, "")) == NULL) { G_fatal_error(_("Vector map <%s> not found"), in_opt->answer); } Vect_set_open_level(1); /* Open input vector */ if (1 > Vect_open_old(&In, in_opt->answer, mapset)) G_fatal_error(_("Unable to open vector map <%s>"), in_opt->answer); /* Input vector must be 3D */ if (!Vect_is_3d(&In)) G_fatal_error(_("Input vector map <%s> is not 3D!"), in_opt->answer); /* Estimate point density and mean distance for current region */ if (spline_step_flag->answer) { double dens, dist; if (P_estimate_splinestep(&In, &dens, &dist) == 0) { G_message("Estimated point density: %.4g", dens); G_message("Estimated mean distance between points: %.4g", dist); } else G_warning(_("No points in current region!")); Vect_close(&In); exit(EXIT_SUCCESS); } /* Open output vector */ if (0 > Vect_open_new(&Out, out_opt->answer, WITH_Z)) G_fatal_error(_("Unable to create vector map <%s>"), out_opt->answer); /* Copy vector Head File */ Vect_copy_head_data(&In, &Out); Vect_hist_copy(&In, &Out); Vect_hist_command(&Out); /* Start driver and open db */ driver = db_start_driver_open_database(dvr, db); if (driver == NULL) G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."), dvr); db_set_error_handler_driver(driver); /* Create auxiliar and interpolation table */ if ((flag_auxiliar = P_Create_Aux4_Table(driver, table_name)) == FALSE) G_fatal_error(_("It was impossible to create <%s>."), table_name); if (P_Create_Aux2_Table(driver, table_interpolation) == FALSE) G_fatal_error(_("It was impossible to create <%s> interpolation table in database."), out_opt->answer); db_create_index2(driver, table_name, "ID"); db_create_index2(driver, table_interpolation, "ID"); /* sqlite likes that ??? */ db_close_database_shutdown_driver(driver); driver = db_start_driver_open_database(dvr, db); /* Setting regions and boxes */ G_get_set_window(&original_reg); G_get_set_window(&elaboration_reg); Vect_region_box(&elaboration_reg, &overlap_box); Vect_region_box(&elaboration_reg, &general_box); /*------------------------------------------------------------------ | Subdividing and working with tiles: | Each original region will be divided into several subregions. | Each one will be overlaped by its neighbouring subregions. | The overlapping is calculated as a fixed OVERLAP_SIZE times | the largest spline step plus 2 * edge ----------------------------------------------------------------*/ /* Fixing parameters of the elaboration region */ P_zero_dim(&dims); nsplx_adj = NSPLX_MAX; nsply_adj = NSPLY_MAX; if (stepN > stepE) dims.overlap = OVERLAP_SIZE * stepN; else dims.overlap = OVERLAP_SIZE * stepE; P_get_edge(P_BICUBIC, &dims, stepE, stepN); P_set_dim(&dims, stepE, stepN, &nsplx_adj, &nsply_adj); G_verbose_message(_("adjusted EW splines %d"), nsplx_adj); G_verbose_message(_("adjusted NS splines %d"), nsply_adj); /* calculate number of subregions */ edgeE = dims.ew_size - dims.overlap - 2 * dims.edge_v; edgeN = dims.sn_size - dims.overlap - 2 * dims.edge_h; N_extension = original_reg.north - original_reg.south; E_extension = original_reg.east - original_reg.west; nsubregion_col = ceil(E_extension / edgeE) + 0.5; nsubregion_row = ceil(N_extension / edgeN) + 0.5; if (nsubregion_col < 0) nsubregion_col = 0; if (nsubregion_row < 0) nsubregion_row = 0; nsubregions = nsubregion_row * nsubregion_col; elaboration_reg.south = original_reg.north; last_row = FALSE; while (last_row == FALSE) { /* For each row */ P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims, GENERAL_ROW); if (elaboration_reg.north > original_reg.north) { /* First row */ P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims, FIRST_ROW); } if (elaboration_reg.south <= original_reg.south) { /* Last row */ P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims, LAST_ROW); last_row = TRUE; } nsply = ceil((elaboration_reg.north - elaboration_reg.south) / stepN) + 0.5; /* if (nsply > NSPLY_MAX) { nsply = NSPLY_MAX; } */ G_debug(1, "nsply = %d", nsply); elaboration_reg.east = original_reg.west; last_column = FALSE; while (last_column == FALSE) { /* For each column */ subregion++; if (nsubregions > 1) G_message(_("subregion %d of %d"), subregion, nsubregions); P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims, GENERAL_COLUMN); if (elaboration_reg.west < original_reg.west) { /* First column */ P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims, FIRST_COLUMN); } if (elaboration_reg.east >= original_reg.east) { /* Last column */ P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims, LAST_COLUMN); last_column = TRUE; } nsplx = ceil((elaboration_reg.east - elaboration_reg.west) / stepE) + 0.5; /* if (nsplx > NSPLX_MAX) { nsplx = NSPLX_MAX; } */ G_debug(1, "nsplx = %d", nsplx); /*Setting the active region */ dim_vect = nsplx * nsply; G_debug(1, "read vector region map"); observ = P_Read_Vector_Region_Map(&In, &elaboration_reg, &npoints, dim_vect, 1); if (npoints > 0) { /* If there is any point falling into elaboration_reg... */ int i, tn; nparameters = nsplx * nsply; /* Mean's calculation */ mean = P_Mean_Calc(&elaboration_reg, observ, npoints); /* Least Squares system */ G_debug(1, _("Allocating memory for bilinear interpolation")); BW = P_get_BandWidth(P_BILINEAR, nsply); /* Bilinear interpolation */ N = G_alloc_matrix(nparameters, BW); /* Normal matrix */ TN = G_alloc_vector(nparameters); /* vector */ parVect_bilin = G_alloc_vector(nparameters); /* Bilinear parameters vector */ obsVect = G_alloc_matrix(npoints + 1, 3); /* Observation vector */ Q = G_alloc_vector(npoints + 1); /* "a priori" var-cov matrix */ lineVect = G_alloc_ivector(npoints + 1); /* Setting obsVect vector & Q matrix */ for (i = 0; i < npoints; i++) { obsVect[i][0] = observ[i].coordX; obsVect[i][1] = observ[i].coordY; obsVect[i][2] = observ[i].coordZ - mean; lineVect[i] = observ[i].lineID; Q[i] = 1; /* Q=I */ } G_free(observ); G_verbose_message(_("Bilinear interpolation")); normalDefBilin(N, TN, Q, obsVect, stepE, stepN, nsplx, nsply, elaboration_reg.west, elaboration_reg.south, npoints, nparameters, BW); nCorrectGrad(N, lambda_B, nsplx, nsply, stepE, stepN); G_math_solver_cholesky_sband(N, parVect_bilin, TN, nparameters, BW); G_free_matrix(N); for (tn = 0; tn < nparameters; tn++) TN[tn] = 0; G_debug(1, _("Allocating memory for bicubic interpolation")); BW = P_get_BandWidth(P_BICUBIC, nsply); N = G_alloc_matrix(nparameters, BW); /* Normal matrix */ parVect_bicub = G_alloc_vector(nparameters); /* Bicubic parameters vector */ G_verbose_message(_("Bicubic interpolation")); normalDefBicubic(N, TN, Q, obsVect, stepE, stepN, nsplx, nsply, elaboration_reg.west, elaboration_reg.south, npoints, nparameters, BW); nCorrectLapl(N, lambda_F, nsplx, nsply, stepE, stepN); G_math_solver_cholesky_sband(N, parVect_bicub, TN, nparameters, BW); G_free_matrix(N); G_free_vector(TN); G_free_vector(Q); G_verbose_message(_("Point classification")); classification(&Out, elaboration_reg, general_box, overlap_box, obsVect, parVect_bilin, parVect_bicub, mean, alpha, grad_H, grad_L, dims.overlap, lineVect, npoints, driver, table_interpolation, table_name); G_free_vector(parVect_bilin); G_free_vector(parVect_bicub); G_free_matrix(obsVect); G_free_ivector(lineVect); } /* IF */ else { G_free(observ); G_warning(_("No data within this subregion. " "Consider changing the spline step.")); } } /*! END WHILE; last_column = TRUE */ } /*! END WHILE; last_row = TRUE */ /* Dropping auxiliar table */ if (npoints > 0) { G_debug(1, _("Dropping <%s>"), table_name); if (P_Drop_Aux_Table(driver, table_name) != DB_OK) G_warning(_("Auxiliar table could not be dropped")); } db_close_database_shutdown_driver(driver); Vect_close(&In); Vect_map_add_dblink(&Out, F_INTERPOLATION, NULL, table_interpolation, "id", db, dvr); Vect_close(&Out); G_done_msg(" "); exit(EXIT_SUCCESS); } /*!END MAIN */
std::vector<Dimension> Reader::getDefaultDimensions() { std::vector<Dimension> output; Dimension alpha("Alpha", dimension::UnsignedInteger, 1, "The alpha image channel value associated with this point"); alpha.setUUID("f3806ee6-e82e-45af-89bd-59b20cda8ffa"); alpha.setNamespace(s_getName()); output.push_back(alpha); Dimension classification("Classification", dimension::UnsignedInteger, 1, "Classification code 0-255"); classification.setUUID("845e23ca-fc4b-4dfc-aa71-a40cc2927421"); classification.setNamespace(s_getName()); output.push_back(classification); Dimension point_source("PointSourceId", dimension::UnsignedInteger, 1, "Flightline number 0-255"); point_source.setUUID("68c03b56-4248-4cca-ade5-33e90d5c5563"); point_source.setNamespace(s_getName()); output.push_back(point_source); Dimension point_source2("PointSourceId", dimension::UnsignedInteger, 2, "Flightline number 0-65536"); point_source2.setUUID("7193bb9f-3ca2-491f-ba18-594321493789"); point_source2.setNamespace(s_getName()); output.push_back(point_source2); Dimension return_number("ReturnNumber", dimension::UnsignedInteger, 1, "Echo/Return Number. 0 - Only echo. 1 - First of many echo. 2 - Intermediate echo. 3 - Last of many echo."); return_number.setUUID("465a9a7e-1e04-47b0-97b6-4f826411bc71"); return_number.setNamespace(s_getName()); output.push_back(return_number); Dimension return_number2("ReturnNumber", dimension::UnsignedInteger, 2, "Echo/Return Number. 0 - Only echo. 1 - First of many echo. 2 - Intermediate echo. 3 - Last of many echo."); return_number2.setUUID("43a1c59d-02ae-4a05-85af-526fae890eb9"); return_number2.setNamespace(s_getName()); output.push_back(return_number2); Dimension flag("Flag", dimension::UnsignedInteger, 1, "Runtime flag (view visibility)"); flag.setUUID("583a5904-ee67-47a7-9fba-2f46daf11441"); flag.setNamespace(s_getName()); output.push_back(flag); Dimension mark("Mark", dimension::UnsignedInteger, 1, "Runtime flag"); mark.setUUID("e889747c-2f19-4244-b282-b0b223868401"); mark.setNamespace(s_getName()); output.push_back(mark); Dimension intensity("Intensity", dimension::UnsignedInteger, 2, "Runtime flag"); intensity.setUUID("beaa015b-20dd-4922-bf1d-da6972596fe6"); intensity.setNamespace(s_getName()); output.push_back(intensity); Dimension x("X", dimension::SignedInteger, 4, "X dimension as a scaled integer"); x.setUUID("64e530ee-7304-4d6a-9fe4-231b6c960e69"); x.setNamespace(s_getName()); output.push_back(x); Dimension y("Y", dimension::SignedInteger, 4, "Y dimension as a scaled integer"); y.setUUID("9b4fce29-2846-45fa-be0c-f50228407f05"); y.setNamespace(s_getName()); output.push_back(y); Dimension z("Z", dimension::SignedInteger, 4, "Z dimension as a scaled integer"); z.setUUID("464cd1f6-5bec-4610-9f25-79e839ee39a6"); z.setNamespace(s_getName()); output.push_back(z); Dimension red("Red", dimension::UnsignedInteger, 1, "Red color value 0 - 256 "); red.setUUID("2157fd43-a492-40e4-a27c-7c37b48bd55c"); red.setNamespace(s_getName()); output.push_back(red); Dimension green("Green", dimension::UnsignedInteger, 1, "Green color value 0 - 256 "); green.setUUID("c9cd71ef-1ce0-48c2-99f8-5b283e598eac"); green.setNamespace(s_getName()); output.push_back(green); Dimension blue("Blue", dimension::UnsignedInteger, 1, "Blue color value 0 - 256 "); blue.setUUID("649f383f-8a7a-4658-ac2a-e1e36cfed05e"); blue.setNamespace(s_getName()); output.push_back(blue); Dimension time("Time", dimension::UnsignedInteger, 4, "32 bit integer time stamps. Time stamps are assumed to be " "GPS week seconds. The storage format is a 32 bit unsigned " "integer where each integer step is 0.0002 seconds."); time.setNumericScale(0.0002); time.setNumericOffset(0.0); time.setUUID("0dcda772-56da-47f6-b04a-edad72361da9"); time.setNamespace(s_getName()); output.push_back(time); return output; }