//! Put time into an ostream static void duration_put(const time_duration_type& td, ostream_type& os) { if(td.is_special()) { os << td.get_rep(); } else { charT fill_char = '0'; if(td.is_negative()) { os << '-'; } os << std::setw(2) << std::setfill(fill_char) << absolute_value(td.hours()) << ":"; os << std::setw(2) << std::setfill(fill_char) << absolute_value(td.minutes()) << ":"; os << std::setw(2) << std::setfill(fill_char) << absolute_value(td.seconds()); fractional_seconds_type frac_sec = absolute_value(td.fractional_seconds()); if (frac_sec != 0) { os << "." << std::setw(time_duration_type::num_fractional_digits()) << std::setfill(fill_char) << frac_sec; } } // else } // duration_put
void print_absolute_value() { long i = -1; float f = -1.0; short s = -1; std::cout << "absolute value of " << i << " is " << absolute_value(i) << std::endl; std::cout << "absolute value of " << f << " is " << absolute_value(f) << std::endl; std::cout << "absolute value of " << s << " is " << absolute_value(s) << std::endl; }
uint64_t platform_get_nanosecond_clock_value(void) { uint64_t nanos; uint32_t cycles; uint32_t diff; cycles = DWT->CYCCNT; /* add values to the ns part of the time which can be divided by 12 */ /* every time such value is added we will increment our clock by 125ns = 1/8 000000( cycle counter is running on the CPU frequency ), */ /* values will be 12, 24, 36, etc */ diff = absolute_value((int)(cycles - prev_cycles)); nsclock_nsec += ( diff / 12 ) * 125; /* when ns counter rolls over, add one second */ if( nsclock_nsec >= 1000000000 ) { nsclock_sec++; nsclock_nsec = nsclock_nsec - 1000000000; } prev_cycles = cycles - (diff % 3); nanos = nsclock_sec; nanos *= 1000000000; nanos += nsclock_nsec; return nanos; }
void operator()(image_type& src) { typedef tipl::image<class image_type::value_type,image_type::dimension> image_buf_type; image_buf_type gx; gradient_2x(src,gx); absolute_value(gx.begin(),gx.end()); gx.swap(src); }
//! Any negative argument results in a negative tick_count static tick_type to_tick_count(hour_type hours, min_type minutes, sec_type seconds, fractional_seconds_type fs) { if (hours < 0 || minutes < 0 || seconds < 0 || fs < 0) { hours = absolute_value(hours); minutes = absolute_value(minutes); seconds = absolute_value(seconds); fs = absolute_value(fs); return (((((fractional_seconds_type(hours)*3600) + (fractional_seconds_type(minutes)*60) + seconds)*res_adjust()) + fs) * -1); } return (((fractional_seconds_type(hours)*3600) + (fractional_seconds_type(minutes)*60) + seconds)*res_adjust()) + fs; }
//############################################################################# // Calculates the dimensions (width, height, depth) of the model. // Also returns the min/maxs of x, y, z of the model. //############################################################################# GLvoid Model::compute_dimensions (GLfloat& maxx, GLfloat&minx, GLfloat& maxy, GLfloat& miny, GLfloat& maxz, GLfloat& minz, GLfloat& width, GLfloat& height, GLfloat& depth) { GLuint i; // get the max/mins maxx = minx = m_vertices[3 + 0]; maxy = miny = m_vertices[3 + 1]; maxz = minz = m_vertices[3 + 2]; for (i = 1; i <= m_numvertices; i++) { if (maxx < m_vertices[3 * i + 0]) maxx = m_vertices[3 * i + 0]; if (minx > m_vertices[3 * i + 0]) minx = m_vertices[3 * i + 0]; if (maxy < m_vertices[3 * i + 1]) maxy = m_vertices[3 * i + 1]; if (miny > m_vertices[3 * i + 1]) miny = m_vertices[3 * i + 1]; if (maxz < m_vertices[3 * i + 2]) maxz = m_vertices[3 * i + 2]; if (minz > m_vertices[3 * i + 2]) minz = m_vertices[3 * i + 2]; } // calculate model width, height, and depth width = absolute_value(maxx) + absolute_value(minx); height = absolute_value(maxy) + absolute_value(miny); depth = absolute_value(maxz) + absolute_value(minz); }
void Computation::checkLegSwing(double velocity[3], Bone * bone, int skelNum) { //TODO find presentation that shows whether the leg swings were detected correctly if(strcmp(bone->name, "lfoot") == 0) { //TODO printf("%f, %f, % f\n",velocity[0], velocity[1], velocity[2] ); if (absolute_value(velocity[2] < 0.0037) ) left = false; else left = true; //printf("\nleft, %f, %f, %f, ",velocity[0], velocity[1], velocity[2]); } else if(strcmp(bone->name, "rfoot") == 0) { //TODO printf("%f, %f, % f\n",velocity[0], velocity[1], velocity[2] ); if(absolute_value(velocity[2]) < 0.0037) right = false; else right = true; //printf("right, %f, %f, %f, ", velocity[0], velocity[1], velocity[2]); } //if (left) printf("left"); //if(right) printf("right"); }
//############################################################################# // Generates texture coordinates according to a // linear projection of the texture map. It generates these by // linearly mapping the vertices onto a square. //############################################################################# GLvoid Model::linear_texture() { Group *group; GLfloat dimensions[3]; GLfloat x, y, scalefactor; GLuint i; if (m_texcoords) delete [] m_texcoords; m_numtexcoords = m_numvertices; m_texcoords= new GLfloat [2*(m_numtexcoords+1)]; GLfloat a, b, c, d, e, f; compute_dimensions(a, b, c, d, e, f, dimensions[0], dimensions[1], dimensions[2]); scalefactor = 2.0 / absolute_value(maximum_value(maximum_value(dimensions[0], dimensions[1]), dimensions[2])); // do the calculations for(i = 1; i <= m_numvertices; i++) { x = m_vertices[3 * i + 0] * scalefactor; y = m_vertices[3 * i + 2] * scalefactor; m_texcoords[2 * i + 0] = (x + 1.0) / 2.0; m_texcoords[2 * i + 1] = (y + 1.0) / 2.0; } // go through and put texture coordinate indices in all the triangles group = m_groups; while(group) { for(i = 0; i < group->numtriangles; i++) { m_triangles[group->triangles[i]].set_tindex(0,m_triangles[group->triangles[i]].inq_vindex(0)); m_triangles[group->triangles[i]].set_tindex(1,m_triangles[group->triangles[i]].inq_vindex(1)); m_triangles[group->triangles[i]].set_tindex(2,m_triangles[group->triangles[i]].inq_vindex(2)); } group = group->next; } }
string cardinal(int x) { string tmp; int a; if(!x) return "zero"; if(x < 0) { tmp = "negative "; x = absolute_value(x); } else tmp = ""; switch(x) { case 1: return tmp+"one"; case 2: return tmp+"two"; case 3: return tmp+"three"; case 4: return tmp+"four"; case 5: return tmp+"five"; case 6: return tmp+"six"; case 7: return tmp+"seven"; case 8: return tmp+"eight"; case 9: return tmp+"nine"; case 10: return tmp+"ten"; case 11: return tmp+"eleven"; case 12: return tmp+"twelve"; case 13: return tmp+"thirteen"; case 14: return tmp+"fourteen"; case 15: return tmp+"fifteen"; case 16: return tmp+"sixteen"; case 17: return tmp+"seventeen"; case 18: return tmp+"eighteen"; case 19: return tmp+"nineteen"; case 20: return tmp+"twenty"; default: if(x > 1000000000) return "over a billion"; else if(a = x /1000000) { if(x = x %1000000) return sprintf("%s million %s", cardinal(a),cardinal(x)); else return sprintf("%s million", cardinal(a)); } else if(a = x / 1000) { if(x = x % 1000) return sprintf("%s thousand %s", cardinal(a),cardinal(x)); else return sprintf("%s thousand", cardinal(a)); } else if(a = x / 100) { if(x = x % 100) return sprintf("%s hundred %s", cardinal(a),cardinal(x)); else return sprintf("%s hundred", cardinal(a)); } else { a = x / 10; if(x = x % 10) tmp = "-"+cardinal(x); else tmp = ""; switch(a) { case 2: return "twenty"+tmp; case 3: return "thirty"+tmp; case 4: return "forty"+tmp; case 5: return "fifty"+tmp; case 6: return "sixty"+tmp; case 7: return "seventy"+tmp; case 8: return "eighty"+tmp; case 9: return "ninety"+tmp; default: return "error"; } } } }
void testcase(gchar *msg, gint parse_flags, gchar *bad_hostname_re, gint expected_pri, unsigned long expected_stamp_sec, unsigned long expected_stamp_usec, unsigned long expected_stamp_ofs, const gchar *expected_host, const gchar *expected_program, const gchar *expected_msg, const gchar *expected_sd_str, const gchar *expected_pid, const gchar *expected_msgid, const gchar *expected_sd_pairs[][2]) { LogMessage *parsed_message; LogStamp *parsed_timestamp; time_t now; GString *sd_str; testcase_begin("Testing log message parsing; parse_flags='%x', bad_hostname_re='%s', msg='%s'", parse_flags, bad_hostname_re ? : "(null)", msg); parsed_message = parse_log_message(msg, parse_flags, bad_hostname_re); parsed_timestamp = &(parsed_message->timestamps[LM_TS_STAMP]); if (expected_stamp_sec) { if (expected_stamp_sec != 1) assert_guint(parsed_timestamp->tv_sec, expected_stamp_sec, "Unexpected timestamp"); assert_guint32(parsed_timestamp->tv_usec, expected_stamp_usec, "Unexpected microseconds"); assert_guint32(parsed_timestamp->zone_offset, expected_stamp_ofs, "Unexpected timezone offset"); } else { time(&now); assert_true(absolute_value(parsed_timestamp->tv_sec - now) <= 5, "Expected parsed message timestamp to be set to now; now='%d', timestamp->tv_sec='%d'", (gint)now, (gint)parsed_timestamp->tv_sec, NULL); } assert_guint16(parsed_message->pri, expected_pri, "Unexpected message priority"); assert_log_message_value(parsed_message, LM_V_HOST, expected_host); assert_log_message_value(parsed_message, LM_V_PROGRAM, expected_program); assert_log_message_value(parsed_message, LM_V_MESSAGE, expected_msg); if (expected_pid) assert_log_message_value(parsed_message, LM_V_PID, expected_pid); if (expected_msgid) assert_log_message_value(parsed_message, LM_V_MSGID, expected_msgid); if (expected_sd_str) { sd_str = g_string_sized_new(0); log_msg_format_sdata(parsed_message, sd_str, 0); assert_string(sd_str->str, expected_sd_str, "Unexpected formatted SData"); g_string_free(sd_str, TRUE); } assert_log_message_sdata_pairs(parsed_message, expected_sd_pairs); log_msg_unref(parsed_message); testcase_end(); }
//Computes the angular momentum about the general center of mass void Computation::computeAngularMomentum() { double translation[3], rotation[3]; double R[4][4],Rx[4][4],Ry[4][4],Rz[4][4]; double mean_w[3]; Bone * root; Mass * mass; if(m_pSkeletonList != NULL) { for (int i = 0; i < numOfSkeletons && i < MAX_SKELS; i++) { double transform[4][4]; identity(transform); double r_i_cm[m_pSkeletonList[i]->NUM_BONES_IN_ASF_FILE][3]; //stores previous position of local center of mass in global cs root = m_pSkeletonList[i]->getRoot(); if(m_pMassDistributionList[i] != NULL) { //reset angular momentum m_pSkeletonList[i]->H[0] = 0.; m_pSkeletonList[i]->H[1] = 0.; m_pSkeletonList[i]->H[2] = 0.; //store old local cm in global cs of each bone: for( int k = 0; k < m_pSkeletonList[i]->NUM_BONES_IN_ASF_FILE; k++) { //store previous position of local cm in global cs in r_i_cm r_i_cm[k][0] = m_pSkeletonList[i]->getBone(root, k)->r_i[0]; r_i_cm[k][1] = m_pSkeletonList[i]->getBone(root, k)->r_i[1]; r_i_cm[k][2] = m_pSkeletonList[i]->getBone(root, k)->r_i[2]; } //compute current position of lcm in global cs m_pSkeletonList[i]->GetTranslation(translation); m_pSkeletonList[i]->GetRotationAngle(rotation); //creating Rotation matrix for initial rotation of Skeleton rotationX(Rx, rotation[0]); rotationY(Ry, rotation[1]); rotationZ(Rz, rotation[2]); matrix4_mult(Rz, Ry, R); matrix4_mult(R, Rx, R); matrix4_mult(transform, R, transform); transform[0][3] += (MOCAP_SCALE*translation [0]); transform[1][3] += (MOCAP_SCALE*translation [1]); transform[2][3] += (MOCAP_SCALE*translation [2]); traverse(root, i, transform, 'h'); //TODO delete mean_w[0] = 0; mean_w[1] = 0; mean_w[2] = 0; for(int j = 0; j < m_pSkeletonList[i]->NUM_BONES_IN_ASF_FILE; j++) { //for every bone compute: (r_i - r_cm) x m_i(v_i - v_cm) + I_i*w_i double rel_pos[3], v_i[3], v_cm[3], v_rel[3], I_G[3][3], w_i[3], local_inertia[3], cross[3], S[3][3], S_transpose[3][3]; Bone * bone; bone = m_pSkeletonList[i]->getBone(root, j); if(m_pMassDistributionList[i]->getMass(bone->name) != NULL) { mass = m_pMassDistributionList[i]->getMass(bone->name); //rel_pos = r_i - r_cm rel_pos[0] = bone->r_i[0] - m_pSkeletonList[i]->cm[0]; rel_pos[1] = bone->r_i[1] - m_pSkeletonList[i]->cm[1]; rel_pos[2] = bone->r_i[2] - m_pSkeletonList[i]->cm[2]; //v_i = r_i - r_i_cm v_i[0] = (bone->r_i[0] - r_i_cm[j][0]); v_i[1] = (bone->r_i[1] - r_i_cm[j][1]); v_i[2] = (bone->r_i[2] - r_i_cm[j][2]); //if v_i is zero switch flag checkLegSwing(v_i, bone, i); // if(mass->mass != 0 && ((strcmp(mass->segName, "rfoot") == 0) || (strcmp(mass->segName, "lfoot") == 0))) printf("v_i_%s: %f %f %f\n",mass->segName, v_i[0], v_i[1], v_i[2]); //v_cm = r_cm - r_cm_prev v_cm[0] = (m_pSkeletonList[i]->cm[0] - m_pSkeletonList[i]->cm_prev[0]); v_cm[1] = (m_pSkeletonList[i]->cm[1] - m_pSkeletonList[i]->cm_prev[1]); v_cm[2] = (m_pSkeletonList[i]->cm[2] - m_pSkeletonList[i]->cm_prev[2]); //v_rel = v_i - v_cm v_rel[0] = v_i[0] - v_cm[0]; v_rel[1] = v_i[1] - v_cm[1]; v_rel[2] = v_i[2] - v_cm[2]; //Inertia tensor double Ri[4][4], Ri_transpose[4][4], I_i[4][4]; //rotation from global to local rotationX(Rx, -bone->axis_x); rotationY(Ry, -bone->axis_y); rotationZ(Rz, -bone->axis_z); matrix4_mult(Rz, Ry, Ri); matrix4_mult(Ri, Rx, Ri); matrix4_transpose(Ri, Ri_transpose); I_i[0][0] = mass->Ixx; I_i[0][1] = I_i[1][0] =(-1)*mass->Ixy; I_i[0][2] = I_i[2][0] = (-1)*mass->Ixz; I_i[1][1] = mass->Iyy; I_i[1][2] = I_i[2][1] = (-1)*mass->Iyz; I_i[2][2] = mass->Izz; I_i[0][3] = I_i[1][3] = I_i[2][3] = 0; I_i[3][0] = I_i[3][1] = I_i[3][2] = 0; I_i[3][3] = 1.0; //~I_G = R_i^T * I_i * R_i //~I_G is inertia tensor relative to bone's cm in rotation of global cs. matrix4_mult(Ri_transpose, I_i, I_i); matrix4_mult(I_i, Ri, I_i); //parallel axes theorem // I_G = I_i + m_i * S^T(rel_pos)* S(rel_pos) with S is skew matrix for cross product cross_matrix(rel_pos, S); //works matrix3_transpose(S, S_transpose);//works matrix3_mult(S_transpose, S, S); //works matrix3_scalar_mult(S, mass->mass); //works //copy entries into I_G identity3(I_G); for (int x = 0; x < 3; x++) for (int y = 0; y < 3; y++) I_G[x][y] = I_i[x][y] + S[x][y]; //w_i = R_i^T * ({rx,ry,rz} - {rx_prev, ry_prev, rz_prev}); w_i[0] = (bone->rx - bone->rx_prev); w_i[1] = (bone->ry - bone->ry_prev); w_i[2] = (bone->rz - bone->rz_prev); //clamping if(absolute_value(w_i[0]) > 1.5) w_i[0] = 0; if(absolute_value(w_i[1]) > 1.5) w_i[1] = 0; if(absolute_value(w_i[2]) > 1.5) w_i[2] = 0; mean_w[0] += absolute_value(w_i[0]); mean_w[1] += absolute_value(w_i[1]); mean_w[2] += absolute_value(w_i[2]); vector_rotationXYZ(w_i, bone->axis_x, bone->axis_y, bone->axis_z); //local_inertia = I_i*w_i matrix3_v3_mult(I_G,w_i, local_inertia); //cross = (r_i - r_cm) x m_i(v_i - v_cm) v_rel[0] *= m_pMassDistributionList[i]->getMass(bone->name)->mass; v_rel[1] *= m_pMassDistributionList[i]->getMass(bone->name)->mass; v_rel[2] *= m_pMassDistributionList[i]->getMass(bone->name)->mass; v3_cross(rel_pos, v_rel, cross); //H is sum of angular momentum of every bone m_pSkeletonList[i]->H[0] += (cross[0] + local_inertia[0]); m_pSkeletonList[i]->H[1] += (cross[1] + local_inertia[1]); m_pSkeletonList[i]->H[2] += (cross[2] + local_inertia[2]); } //if end }//for bones end setLegSwing(i); mean_w[0] /= m_pSkeletonList[i]->NUM_BONES_IN_ASF_FILE; mean_w[1] /= m_pSkeletonList[i]->NUM_BONES_IN_ASF_FILE; mean_w[2] /= m_pSkeletonList[i]->NUM_BONES_IN_ASF_FILE; //normalization N=M*H*V // to make H dimensionless, divide by subject's height (in m), subject's mass (in kg) and subject's average velocity(0.012 m/frame or 1.44 m/s) double n = m_pSkeletonList[i]->totalMass*m_pSkeletonList[i]->height*(1.44); m_pSkeletonList[i]->H[0] /= n; m_pSkeletonList[i]->H[1] /= n; m_pSkeletonList[i]->H[2] /= n; //printf("mean w values: %f %f %f\n", mean_w[0], mean_w[1], mean_w[2]); //printf("angular momentum: %f %f %f\n", m_pSkeletonList[i]->H[0],m_pSkeletonList[i]->H[1],m_pSkeletonList[i]->H[2]); //printf("position cm: %f %f %f\n", m_pSkeletonList[i]->cm[0], m_pSkeletonList[i]->cm[1], m_pSkeletonList[i]->cm[2]); }//if end }// for Skeletons end } }
void solve_bicgstab(const MatrixExpression &A, const PreconditionerExpression &preconditioner, VectorTypeX &result, const VectorExpressionB &b, double tol, unsigned max_iterations, unsigned *iteration_count = NULL, unsigned debug_level = 0) { typedef VectorTypeX vector_t; typedef typename vector_t::value_type v_t; typedef typename decomplexify<v_t>::type real_t; if (A().size1() != A().size2()) throw std::runtime_error("bicgstab: A is not quadratic"); if (debug_level >= 2) std::cout << "rhs:" << b << std::endl; // typed up from Figure 2.10 of // Templates for the Solution of Linear Systems: // Building Blocks for Iterative Methods // (R. Barrett, M. Berry, T. F. Chan, et al.) unsigned iterations = 0; // "next" refers to i // "" refers to i-1 // "last" refers to i-2 v_t rho, last_rho, alpha, omega; vector_t p, v, x(result); vector_t r(b-prod(A,x)); vector_t r_tilde(r); real_t initial_residual = norm_2(r); // silence "used uninitialized" warnings last_rho = 0; alpha = 0; while (iterations < max_iterations) { rho = inner_prod(conj(r_tilde), r); if (absolute_value(rho) == 0) throw std::runtime_error("bicgstab failed, rho == 0"); if (iterations == 0) { p = r; } else { v_t beta = (rho/last_rho)*(alpha/omega); p = r + beta*(p-omega*v); } vector_t p_hat = prod(preconditioner, p); v = prod(A, p_hat); alpha = rho/inner_prod(conj(r_tilde), v); vector_t s = r - alpha*v; { real_t norm_s = norm_2(s); if (norm_s < tol * initial_residual) { x += alpha*p_hat; break; } } vector_t s_hat = prod(preconditioner, s); vector_t t = prod(A, s_hat); omega = inner_prod(conj(t), s)/inner_prod(conj(t), t); x += alpha * p_hat + omega * s_hat; r = s - omega * t; { real_t norm_r = norm_2(r); if (norm_r < tol * initial_residual) break; } if (absolute_value(omega) == 0) throw std::runtime_error("bicgstab failed, omega == 0"); last_rho = rho; if (debug_level) { if (debug_level >= 2 || iterations % 10 == 0) std::cout << double(norm_2(r)) << std::endl; } iterations++; } result = x; if ( iterations == max_iterations) throw std::runtime_error("bicgstab failed to converge"); if (iteration_count) *iteration_count = iterations; }
int main(int argc, char** argv) { if (argc < 5) { std::cout << "Usage: patt_rec [data_matrix.txt] [pattern_matrix.txt] [mode 0: serial, 1: parallel] [number of threads]" << std::endl; return 1; } int data_n_rows, data_n_cols; std::ifstream data_file(argv[1]); if (!data_file) error_exit("Data file not found!"); data_file >> data_n_rows >> data_n_cols; int data[data_n_rows][data_n_cols]; for (int i = 0; i < data_n_rows; ++i) { for (int j = 0; j < data_n_cols; ++j) { data_file >> data[i][j]; } } int pattern_n_rows, pattern_n_cols; std::ifstream pattern_file(argv[2]); if (!pattern_file) error_exit("Pattern file not found"); pattern_file >> pattern_n_rows >> pattern_n_cols; int pattern[pattern_n_rows][pattern_n_cols]; std::vector<int> pattern_elements; for (int i = 0; i < pattern_n_rows; ++i) { for (int j = 0; j < pattern_n_cols; ++j) { pattern_file >> pattern[i][j]; pattern_elements.push_back(pattern[i][j]); } } std::nth_element(pattern_elements.begin(), pattern_elements.begin() + pattern_elements.size()/2, pattern_elements.end()); const int median_pattern = pattern_elements[pattern_elements.size()/2]; std::vector<std::tuple<int, int, double>> matches; double size_of_pattern_matrix = (double) pattern_n_cols * pattern_n_rows; //Evil C way. bool is_parallel {atoi(argv[3]) == 1}; //Absolutly horribly... but works. Should be checked with a stream. double time_start = omp_get_wtime(); int num_of_threads = atoi(argv[4]); int chunk_size = data_n_rows / (num_of_threads * 10); #pragma omp parallel for num_threads(num_of_threads) if(is_parallel) schedule(guided, chunk_size) for (int i = 0; i < data_n_rows - pattern_n_rows; ++i) { std::cout << omp_get_thread_num() << std::endl; for (int j = 0; j < data_n_cols - pattern_n_cols; ++j) { double current_goodness = 0; std::vector<int>submatrix_elements; for (int m_i = 0; m_i < pattern_n_rows; ++m_i) { for (int m_j = 0; m_j < pattern_n_cols; ++m_j) { int diff = absolute_value(data[i+m_i][j+m_j] - pattern[m_i][m_j]); current_goodness += (double)diff; submatrix_elements.push_back(data[i+m_i][j+m_j]); if (diff > 9) goto BREAK_OUUUUUUUT; } } std::nth_element(submatrix_elements.begin(), submatrix_elements.begin() + submatrix_elements.size()/2, submatrix_elements.end()); if (absolute_value(submatrix_elements[submatrix_elements.size()/2] - median_pattern) > 2) goto BREAK_OUUUUUUUT; current_goodness /= size_of_pattern_matrix; #pragma omp critical matches.push_back(std::make_tuple(i, j, current_goodness)); BREAK_OUUUUUUUT : ; } } double time_end = omp_get_wtime(); std::cout << "Took " << (time_end - time_start) << " seconds" << std::endl; std::cout << "Matches (row, col, goodness)" << std::endl; double min_goodness {std::numeric_limits<double>::max()}, max_goodness {std::numeric_limits<double>::min()}, average_goodness {0}; for (auto p : matches) { std::cout << "(" << std::get<0>(p) << ", " << std::get<1>(p) << ", " << std::get<2>(p) << ")" << std::endl; double current_goodness = std::get<2>(p); if (current_goodness < min_goodness) min_goodness = current_goodness; if (current_goodness > max_goodness) max_goodness = current_goodness; average_goodness += current_goodness; } std::cout << "Min goodness: " << min_goodness << std::endl << "Max goodness: " << max_goodness << std::endl << "Average goodness: " << average_goodness / matches.size() << std::endl; return 0; }
/* The benchmarking program */ int main (int argc, char **argv) { printf ("Description:\t%s\n\n", dgemm_desc); /* Test sizes should highlight performance dips at multiples of certain powers-of-two */ int test_sizes[] = /* Multiples-of-32, +/- 1. Currently commented. */ {31,32,33,63,64,65,95,96,97,127,128,129,159,160,161,191,192,193,223,224,225,255,256,257,287,288,289,319,320,321,351,352,353,383,384,385,415,416,417,447,448,449,479,480,481,511,512,513,543,544,545,575,576,577,607,608,609,639,640,641,671,672,673,703,704,705,735,736,737,767,768,769,799,800,801,831,832,833,863,864,865,895,896,897,927,928,929,959,960,961,991,992,993,1023,1024,1025}; /* A representative subset of the first list. Currently uncommented. */ //{ 31, 32, 96, 97, 127, 128, 129, 191, 192, 229, 255, 256, 257, // 319, 320, 321, 417, 479, 480, 511, 512, 639, 640, 767, 768, 769 }; int nsizes = sizeof(test_sizes)/sizeof(test_sizes[0]); /* assume last size is also the largest size */ int nmax = test_sizes[nsizes-1]; /* allocate memory for all problems */ double* buf = NULL; buf = (double*) malloc (3 * nmax * nmax * sizeof(double)); if (buf == NULL) die ("failed to allocate largest problem size"); double Mflops_s[nsizes],per[nsizes],aveper; /* For each test size */ for (int isize = 0; isize < sizeof(test_sizes)/sizeof(test_sizes[0]); ++isize) { for( int block_size = 3;block_size<200;block_size++) { /* Create and fill 3 random matrices A,B,C*/ int n = test_sizes[isize]; double* A = buf + 0; double* B = A + nmax*nmax; double* C = B + nmax*nmax; fill (A, n*n); fill (B, n*n); fill (C, n*n); /* Measure performance (in Gflops/s). */ /* Time a "sufficiently long" sequence of calls to reduce noise */ double Gflops_s, seconds = -1.0; double timeout = 0.1; // "sufficiently long" := at least 1/10 second. for (int n_iterations = 1; seconds < timeout; n_iterations *= 2) { /* Warm-up */ square_dgemm (block_size,n, A, B, C); /* Benchmark n_iterations runs of square_dgemm */ seconds = -wall_time(); for (int it = 0; it < n_iterations; ++it) square_dgemm (block_size,n, A, B, C); seconds += wall_time(); /* compute Gflop/s rate */ Gflops_s = 2.e-9 * n_iterations * n * n * n / seconds; } /* Storing Mflop rate and calculating percentage of peak */ Mflops_s[isize] = Gflops_s*1000; per[isize] = Gflops_s*100/MAX_SPEED; printf ("Size: %d\t Block Size: %d\t Mflop/s: %8g\tPercentage:%6.2lf\n", n, block_size,Mflops_s[isize],per[isize]); /* Ensure that error does not exceed the theoretical error bound. */ /* C := A * B, computed with square_dgemm */ memset (C, 0, n * n * sizeof(double)); square_dgemm (block_size,n, A, B, C); /* Do not explicitly check that A and B were unmodified on square_dgemm exit * - if they were, the following will most likely detect it: * C := C - A * B, computed with reference_dgemm */ reference_dgemm(n, -1., A, B, C); /* A := |A|, B := |B|, C := |C| */ absolute_value (A, n * n); absolute_value (B, n * n); absolute_value (C, n * n); /* C := |C| - 3 * e_mach * n * |A| * |B|, computed with reference_dgemm */ reference_dgemm (n, -3.*DBL_EPSILON*n, A, B, C); /* If any element in C is positive, then something went wrong in square_dgemm */ for (int i = 0; i < n * n; ++i) if (C[i] > 0) die("*** FAILURE *** Error in matrix multiply exceeds componentwise error bounds.\n" ); } } free (buf); return 0; }
int main( int argc, char **argv ) { printf ("Description:\t%s\n\n", dgemm_desc); /* These sizes should highlight performance dips at multiples of certain powers-of-two */ int test_sizes[] = { 31, 32, 96, 97, 127, 128, 129, 191, 192, 229, 255, 256, 257, 319, 320, 321, 417, 479, 480, 511, 512, 639, 640, 767, 768, 769, }; /*For each test size*/ for( int isize = 0; isize < sizeof(test_sizes)/sizeof(test_sizes[0]); isize++ ) { /*Craete and fill 3 random matrices A,B,C*/ int n = test_sizes[isize]; double *A = (double*) malloc( n * n * sizeof(double) ); double *B = (double*) malloc( n * n * sizeof(double) ); double *C = (double*) malloc( n * n * sizeof(double) ); fill( A, n * n ); fill( B, n * n ); fill( C, n * n ); /* measure Mflop/s rate; time a sufficiently long sequence of calls to eliminate noise*/ double Mflop_s, seconds = -1.0; for( int n_iterations = 1; seconds < 0.1; n_iterations *= 2 ) { /* warm-up */ square_dgemm( n, A, B, C ); /* measure time */ seconds = read_timer( ); for( int i = 0; i < n_iterations; i++ ) square_dgemm( n, A, B, C ); seconds = read_timer( ) - seconds; /* compute Mflop/s rate */ Mflop_s = 2e-6 * n_iterations * n * n * n / seconds; } printf ("Size: %d\tMflop/s: %g\n", n, Mflop_s); /* Ensure that error does not exceed the theoretical error bound */ /* Set initial C to 0 and do matrix multiply of A*B */ memset( C, 0, sizeof( double ) * n * n ); square_dgemm( n, A, B, C ); /*Subtract A*B from C using standard dgemm (note that this should be 0 to within machine roundoff)*/ dgemm( 'N','N', n,n,n, -1, A,n, B,n, 1, C,n ); /*Subtract the maximum allowed roundoff from each element of C*/ absolute_value( A, n * n ); absolute_value( B, n * n ); absolute_value( C, n * n ); dgemm( 'N','N', n,n,n, -3.0*DBL_EPSILON*n, A,n, B,n, 1, C,n ); /*After this test if any element in C is still positive something went wrong in square_dgemm*/ for( int i = 0; i < n * n; i++ ) if( C[i] > 0 ) { printf( "FAILURE: error in matrix multiply exceeds an acceptable margin\n" ); exit(-1); } /*Deallocate memory*/ free( C ); free( B ); free( A ); } return 0; }
//! Returns count of fractional seconds at given resolution fractional_seconds_type fractional_seconds() const { return absolute_value((ticks()%rep_type::res_adjust())); }
//! Returns normalized number of seconds sec_type seconds() const { return absolute_value((ticks()/rep_type::res_adjust()) % 60); }
//! Returns normalized number of minutes min_type minutes() const { return absolute_value(((ticks() / (60*rep_type::res_adjust())) % 60)); }
int testcase(gchar *msg, gint parse_flags, /* LP_NEW_PROTOCOL */ gchar *bad_hostname_re, gint expected_pri, guint expected_version, unsigned long expected_stamps_sec, unsigned long expected_stamps_usec, unsigned long expected_stamps_ofs, const gchar *expected_host, const gchar *expected_msg, const gchar *expected_program, const gchar *expected_sd_str, const gchar *expected_process_id, const gchar *expected_message_id ) { LogMessage *logmsg, *cloned; time_t now; regex_t bad_hostname; GSockAddr *addr = g_sockaddr_inet_new("10.10.10.10", 1010); gchar logmsg_addr[256], cloned_addr[256]; LogPathOptions path_options = LOG_PATH_OPTIONS_INIT; GString *sd_str = g_string_sized_new(0); if (bad_hostname_re) TEST_ASSERT(regcomp(&bad_hostname, bad_hostname_re, REG_NOSUB | REG_EXTENDED) == 0, "%d", 0, 0); parse_options.flags = parse_flags; parse_options.bad_hostname = &bad_hostname; logmsg = log_msg_new(msg, strlen(msg), addr, &parse_options); TEST_ASSERT(logmsg->pri == expected_pri, "%d", logmsg->pri, expected_pri); if (expected_stamps_sec) { if (expected_stamps_sec != 1) { TEST_ASSERT(logmsg->timestamps[LM_TS_STAMP].time.tv_sec == expected_stamps_sec, "%d", (int) logmsg->timestamps[LM_TS_STAMP].time.tv_sec, (int) expected_stamps_sec); } TEST_ASSERT(logmsg->timestamps[LM_TS_STAMP].time.tv_usec == expected_stamps_usec, "%d", (int) logmsg->timestamps[LM_TS_STAMP].time.tv_usec, (int) expected_stamps_usec); TEST_ASSERT(logmsg->timestamps[LM_TS_STAMP].zone_offset == expected_stamps_ofs, "%d", (int) logmsg->timestamps[LM_TS_STAMP].zone_offset, (int) expected_stamps_ofs); } else { time(&now); TEST_ASSERT(absolute_value(logmsg->timestamps[LM_TS_STAMP].time.tv_sec - now) < 1, "%d", 0, 0); } TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_HOST, NULL), expected_host) == 0, "%s", log_msg_get_value(logmsg, LM_V_HOST, NULL), expected_host); TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_PROGRAM, NULL), expected_program) == 0, "%s", log_msg_get_value(logmsg, LM_V_PROGRAM, NULL), expected_program); TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_MESSAGE, NULL), expected_msg) == 0, "%s", log_msg_get_value(logmsg, LM_V_MESSAGE, NULL), expected_msg); TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_PID, NULL), expected_process_id) == 0, "%s", log_msg_get_value(logmsg, LM_V_PID, NULL), expected_process_id); TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_MSGID, NULL), expected_message_id) == 0, "%s", log_msg_get_value(logmsg, LM_V_MSGID, NULL), expected_message_id); /* SD elements */ log_msg_format_sdata(logmsg, sd_str); TEST_ASSERT(strcmp(sd_str->str, expected_sd_str) == 0, "%s", sd_str->str, expected_sd_str); /* check if the sockaddr matches */ g_sockaddr_format(logmsg->saddr, logmsg_addr, sizeof(logmsg_addr), GSA_FULL); path_options.flow_control = FALSE; cloned = log_msg_clone_cow(logmsg, &path_options); g_sockaddr_format(cloned->saddr, cloned_addr, sizeof(cloned_addr), GSA_FULL); TEST_ASSERT(strcmp(logmsg_addr, cloned_addr) == 0, "%s", cloned_addr, logmsg_addr); TEST_ASSERT(logmsg->pri == cloned->pri, "%d", logmsg->pri, cloned->pri); TEST_ASSERT(logmsg->timestamps[LM_TS_STAMP].time.tv_sec == cloned->timestamps[LM_TS_STAMP].time.tv_sec, "%d", (int) logmsg->timestamps[LM_TS_STAMP].time.tv_sec, (int) cloned->timestamps[LM_TS_STAMP].time.tv_sec); TEST_ASSERT(logmsg->timestamps[LM_TS_STAMP].time.tv_usec == cloned->timestamps[LM_TS_STAMP].time.tv_usec, "%d", (int) logmsg->timestamps[LM_TS_STAMP].time.tv_usec, (int) cloned->timestamps[LM_TS_STAMP].time.tv_usec); TEST_ASSERT(logmsg->timestamps[LM_TS_STAMP].zone_offset == cloned->timestamps[LM_TS_STAMP].zone_offset, "%d", (int) logmsg->timestamps[LM_TS_STAMP].zone_offset, (int) cloned->timestamps[LM_TS_STAMP].zone_offset); TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_HOST, NULL), log_msg_get_value(cloned, LM_V_HOST, NULL)) == 0, "%s", log_msg_get_value(logmsg, LM_V_HOST, NULL), log_msg_get_value(cloned, LM_V_HOST, NULL)); TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_PROGRAM, NULL), log_msg_get_value(cloned, LM_V_PROGRAM, NULL)) == 0, "%s", log_msg_get_value(logmsg, LM_V_PROGRAM, NULL), log_msg_get_value(cloned, LM_V_PROGRAM, NULL)); TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_MESSAGE, NULL), log_msg_get_value(cloned, LM_V_MESSAGE, NULL)) == 0, "%s", log_msg_get_value(logmsg, LM_V_MESSAGE, NULL), log_msg_get_value(cloned, LM_V_MESSAGE, NULL)); TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_PID, NULL), log_msg_get_value(cloned, LM_V_PID, NULL)) == 0, "%s", log_msg_get_value(logmsg, LM_V_PID, NULL), log_msg_get_value(cloned, LM_V_PID, NULL)); TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_MSGID, NULL), log_msg_get_value(cloned, LM_V_MSGID, NULL)) == 0, "%s", log_msg_get_value(logmsg, LM_V_MSGID, NULL), log_msg_get_value(cloned, LM_V_MSGID, NULL)); /* SD elements */ log_msg_format_sdata(cloned, sd_str); TEST_ASSERT(strcmp(sd_str->str, expected_sd_str) == 0, "%s", sd_str->str, expected_sd_str); log_msg_set_value(cloned, LM_V_HOST, "newhost", -1); log_msg_set_value(cloned, LM_V_HOST_FROM, "newhost", -1); log_msg_set_value(cloned, LM_V_MESSAGE, "newmsg", -1); log_msg_set_value(cloned, LM_V_PROGRAM, "newprogram", -1); log_msg_set_value(cloned, LM_V_PID, "newpid", -1); log_msg_set_value(cloned, LM_V_MSGID, "newmsgid", -1); log_msg_set_value(cloned, LM_V_SOURCE, "newsource", -1); log_msg_set_value(cloned, log_msg_get_value_handle("newvalue"), "newvalue", -1); /* retest values in original logmsg */ TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_HOST, NULL), expected_host) == 0, "%s", log_msg_get_value(logmsg, LM_V_HOST, NULL), expected_host); TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_PROGRAM, NULL), expected_program) == 0, "%s", log_msg_get_value(logmsg, LM_V_PROGRAM, NULL), expected_program); TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_MESSAGE, NULL), expected_msg) == 0, "%s", log_msg_get_value(logmsg, LM_V_MESSAGE, NULL), expected_msg); TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_PID, NULL), expected_process_id) == 0, "%s", log_msg_get_value(logmsg, LM_V_PID, NULL), expected_process_id); TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_MSGID, NULL), expected_message_id) == 0, "%s", log_msg_get_value(logmsg, LM_V_MSGID, NULL), expected_message_id); TEST_ASSERT(strcmp(log_msg_get_value(logmsg, LM_V_SOURCE, NULL), "") == 0, "%s", log_msg_get_value(logmsg, LM_V_SOURCE, NULL), ""); /* check newly set values in cloned */ TEST_ASSERT(strcmp(log_msg_get_value(cloned, LM_V_HOST, NULL), "newhost") == 0, "%s", log_msg_get_value(cloned, LM_V_HOST, NULL), "newhost"); TEST_ASSERT(strcmp(log_msg_get_value(cloned, LM_V_HOST_FROM, NULL), "newhost") == 0, "%s", log_msg_get_value(cloned, LM_V_HOST_FROM, NULL), "newhost"); TEST_ASSERT(strcmp(log_msg_get_value(cloned, LM_V_PROGRAM, NULL), "newprogram") == 0, "%s", log_msg_get_value(cloned, LM_V_PROGRAM, NULL), "newprogram"); TEST_ASSERT(strcmp(log_msg_get_value(cloned, LM_V_MESSAGE, NULL), "newmsg") == 0, "%s", log_msg_get_value(cloned, LM_V_MESSAGE, NULL), "newmsg"); TEST_ASSERT(strcmp(log_msg_get_value(cloned, LM_V_PID, NULL), "newpid") == 0, "%s", log_msg_get_value(cloned, LM_V_PID, NULL), "newpid"); TEST_ASSERT(strcmp(log_msg_get_value(cloned, LM_V_MSGID, NULL), "newmsgid") == 0, "%s", log_msg_get_value(cloned, LM_V_MSGID, NULL), "newmsgid"); TEST_ASSERT(strcmp(log_msg_get_value(cloned, LM_V_SOURCE, NULL), "newsource") == 0, "%s", log_msg_get_value(cloned, LM_V_SOURCE, NULL), "newsource"); log_msg_unref(cloned); log_msg_unref(logmsg); g_string_free(sd_str, TRUE); return 0; }
int main( int argc, char **argv ) { int done = 0, myid, numprocs, i; int from, to; int namelen; char processor_name[MPI_MAX_PROCESSOR_NAME]; double seconds, Mflop_s;; int root_process = 0; int n_iterations = 1, iter = 0; int n = 1600; double *A = (double*) malloc( n * n * sizeof(double) ); double *B = (double*) malloc( n * n * sizeof(double) ); double *C = (double*) malloc( n * n * sizeof(double) ); MPI_Init(&argc,&argv); MPI_Comm_size(MPI_COMM_WORLD,&numprocs); MPI_Comm_rank(MPI_COMM_WORLD,&myid); MPI_Get_processor_name(processor_name,&namelen); /* These sizes should highlight performance dips at multiples of certain powers-of-two */ /*Craete and fill 3 random matrices A,B,C*/ from = myid * n/numprocs; to = (myid+1) * n/numprocs; if(myid == root_process){ printf ("Description:\t%s\n\n", dgemm_desc); n_iterations = 1; } START: if (myid == root_process){ fill( A, n * n ); fill( B, n * n ); //fill( C, n * n ); memset( C, 0, sizeof( double ) * n * n ); } MPI_Bcast(A, n * n, MPI_DOUBLE, 0,MPI_COMM_WORLD); MPI_Bcast(B, n * n, MPI_DOUBLE, 0,MPI_COMM_WORLD); MPI_Bcast(C, n * n, MPI_DOUBLE, 0,MPI_COMM_WORLD); if(myid == root_process){ iter = 0; } double *T = (double*) malloc( n * n * sizeof(double) ); ITERATION: if(myid == root_process){ seconds = MPI_Wtime(); } square_dgemm(n, from, to, A, B, C, T); // MPI_Barrier(MPI_COMM_WORLD); MPI_Gather(T + from * n, n * (n / numprocs), MPI_DOUBLE, C + from * n, n * (n / numprocs), MPI_DOUBLE, 0, MPI_COMM_WORLD); /* if (iter < n_iterations){ iter++; goto ITERATION; } seconds = MPI_Wtime() - seconds; if (seconds < 0.1){ n_iterations *= 2; goto START; } */ seconds = MPI_Wtime() - seconds; Mflop_s = 1e-6 * n_iterations * n * n * n / seconds; printf("Mflops: %g time: %g \n", Mflop_s, seconds); cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, n,n,n, -1, A,n, B,n, 1, C,n ); /*Subtract the maximum allowed roundoff from each element of C*/ absolute_value( A, n * n ); absolute_value( B, n * n ); absolute_value( C, n * n ); //dgemm( 'N','N', n,n,n, -3.0*DBL_EPSILON*n, A,n, B,n, 1, C,n ); cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, n,n,n, -3.0*DBL_EPSILON*n, A,n, B,n, 1, C,n ); /*After this test if any element in C is still positive something went wrong in square_dgemm*/ for( int i = 0; i < n * n; i++ ) if( C[i] > 0 ) { printf( "FAILURE: error in matrix multiply exceeds an acceptable margin\n" ); exit(-1); } /* if (iter < n_iterations){ iter++; goto ITERATION; } seconds = MPI_Wtime() - seconds; if (seconds < 0.1){ n_iterations *= 2; goto START; } */ }