splatclient::splatclient(string windowstyle,nCursesWindow *window, string ip, unsigned int port) { //SSL stuff SSL_library_init(); ERR_load_crypto_strings(); ERR_load_SSL_strings(); OpenSSL_add_all_algorithms(); // init receive buffer recv_buff.iMessageid=recv_buff.tSize=0; memset(&(recv_buff.cMesg), '\0',CHUNK); sessionID=0; win=window; sockfd=-1; log= new cLogfile("splatclient.log",false); msgID=0; server_ip=ip; server_port=port; // vParseWindowstyle(windowstyle, window); if (!win) { sLogelement C1(-1, "Keine Windowfunktion übergeben", false); (*log)<<C1; exit(1); } sLogelement C1(0, "Splatclient erschaffen", true); (*log)<<C1; *win<<C1; if (!bConnect(port, ip)) { win->windowstack.back()->nCgetwin().~nCursesWindow(); exit(1); } else { sLogelement C1(-1, "Verbindung hergestellt", true); *win<<C1; } keypad(stdscr,true); nodelay(win->windowstack.back()->win, true); if (!iGetsocket()) { sLogelement t1(-1,"No socket found!",false);//FATAL *win<<t1; win->windowstack.back()->nCgetwin().~nCursesWindow(); (*log) << t1; exit(1); } //cFlow_client bkgactive=true; //still need to be active for ping/pong messages //MENU menu=NULL; vCreateMenu(); bDirty=true; }
void foo(int coin) { C1 c1 = coin ? C1(1) : C1(2); if (coin) { clang_analyzer_eval(c1.getX() == 1); // expected-warning{{TRUE}} } else { clang_analyzer_eval(c1.getX() == 2); // expected-warning{{TRUE}} } C2 c2 = coin ? C2(3, 4) : C2(5, 6); if (coin) { clang_analyzer_eval(c2.getX() == 3); // expected-warning{{TRUE}} clang_analyzer_eval(c2.getY() == 4); // expected-warning{{TRUE}} } else { clang_analyzer_eval(c2.getX() == 5); // expected-warning{{TRUE}} clang_analyzer_eval(c2.getY() == 6); // expected-warning{{TRUE}} } }
int main() { C0().f0(); C1().f0(); C1().f1(); C2().f0(); C2().f1(); C2().f2(); C3().f0(); C3().f1(); C3().f2(); C3().f3(); }
int test_vector_add() { // Blog: http://blog.csdn.net/fengbingchun/article/details/74120057 // Vector addition: C = A + B, implements element by element vector addition const int numElements{ 50000 }; std::vector<float> A(numElements), B(numElements), C1(numElements), C2(numElements); // Initialize vector for (int i = 0; i < numElements; ++i) { A[i] = rand() / (float)RAND_MAX; B[i] = rand() / (float)RAND_MAX; } float elapsed_time1{ 0.f }, elapsed_time2{ 0.f }; // milliseconds int ret = vector_add_cpu(A.data(), B.data(), C1.data(), numElements, &elapsed_time1); if (ret != 0) PRINT_ERROR_INFO(vectorAdd_cpu); ret = vector_add_gpu(A.data(), B.data(), C2.data(), numElements, &elapsed_time2); if (ret != 0) PRINT_ERROR_INFO(vectorAdd_gpu); for (int i = 0; i < numElements; ++i) { if (fabs(C1[i] - C2[i]) > EPS_) { fprintf(stderr, "Result verification failed at element %d!\n", i); return -1; } } fprintf(stderr, "cpu run time: %f ms, gpu run time: %f ms\n", elapsed_time1, elapsed_time2); return 0; }
int test_long_vector_add() { // Blog: http://blog.csdn.net/fengbingchun/article/details/75570546 const int length{ 100000000 }; std::unique_ptr<float[]> A(new float[length]); std::unique_ptr<float[]> B(new float[length]); std::unique_ptr<float[]> C1(new float[length]); std::unique_ptr<float[]> C2(new float[length]); generator_random_number(A.get(), length, -1000.f, 1000.f); generator_random_number(B.get(), length, -1000.f, 1000.f); float elapsed_time1{ 0.f }, elapsed_time2{ 0.f }; // milliseconds int ret = long_vector_add_cpu(A.get(), B.get(), C1.get(), length, &elapsed_time1); if (ret != 0) PRINT_ERROR_INFO(long_vector_add_cpu); ret = long_vector_add_gpu(A.get(), B.get(), C2.get(), length, &elapsed_time2); if (ret != 0) PRINT_ERROR_INFO(matrix_mul_gpu); int count_error{ 0 }; for (int i = 0; i < length; ++i) { if (count_error > 100) return -1; if (fabs(C1[i] - C2[i]) > EPS_) { fprintf(stderr, "Result verification failed at element %d, C1: %f, C2: %f\n", i, C1[i], C2[i]); ++count_error; } } fprintf(stderr, "cpu run time: %f ms, gpu run time: %f ms\n", elapsed_time1, elapsed_time2); return 0; }
//-------------------------------------------------------------- void ofApp::setup(){ ofSetFrameRate(60.0f); for(int i=0;i<12;i++) { randColorDrop(); } Attractor.reset(new ColorDropAttractor()); Merger.reset(new ColorDropMerger()); Dragger.reset(new ColorDropDragger()); ofPtr<ColorHole> H; ofFloatColor C0(ofFloatColor::yellow); C0.setBrightness(0.7f); H.reset(new ColorHole( ofVec2f(200,200), C0,2600)); Holes.push_back(H); ofFloatColor C1(ofFloatColor::cyan); C1.setBrightness(0.7f); H.reset(new ColorHole( ofVec2f(750,240), ofFloatColor(0.8f,0.0f,0.8f,1),3000)); Holes.push_back(H); ofFloatColor C2(ofFloatColor::violet); C2.setBrightness(0.7f); H.reset(new ColorHole( ofVec2f(450,500), ofFloatColor(0.0f,0.9f,0.9f,1),3800)); Holes.push_back(H); }
int test_matrix_mul() { // Blog: http://blog.csdn.net/fengbingchun/article/details/76618165 // Matrix multiplication: C = A * B // 矩阵A、B的宽、高应是32的整数倍 const int rowsA{ 352 }, colsA{ 672 }, rowsB = colsA, colsB{ 384 }; std::unique_ptr<float[]> A(new float[colsA*rowsA]); std::unique_ptr<float[]> B(new float[colsB*rowsB]); std::unique_ptr<float[]> C1(new float[rowsA*colsB]); std::unique_ptr<float[]> C2(new float[rowsA*colsB]); generator_random_number(A.get(), colsA*rowsA, -1.f, 1.f); generator_random_number(B.get(), colsB*rowsB, -1.f, 1.f); float elapsed_time1{ 0.f }, elapsed_time2{ 0.f }; // milliseconds int ret = matrix_mul_cpu(A.get(), B.get(), C1.get(), colsA, rowsA, colsB, rowsB, &elapsed_time1); if (ret != 0) PRINT_ERROR_INFO(matrix_mul_cpu); ret = matrix_mul_gpu(A.get(), B.get(), C2.get(), colsA, rowsA, colsB, rowsB, &elapsed_time2); if (ret != 0) PRINT_ERROR_INFO(matrix_mul_gpu); int count{ 0 }; for (int i = 0; i < rowsA*colsB; ++i) { if (count > 100) return -1; if (fabs(C1[i] - C2[i]) > EPS_) { fprintf(stderr, "Result verification failed at element %d, C1: %f, C2: %f\n", i, C1[i], C2[i]); ++count; } } fprintf(stderr, "test matrix mul: cpu run time: %f ms, gpu run time: %f ms\n", elapsed_time1, elapsed_time2); return 0; }
void graphics::NgoiLang(QPainter& painter,int x,int y,int c,int r) { QPoint A(x-r/2,y+c); QPoint B(x+r/2,y+c); QPoint C(x+r/2,y+c/3); QPoint D(x,y); QPoint E(x-r/2,y+c/3); QPolygon poly1; poly1 << D << E << A << B << C; painter.drawPolygon(poly1); // ve cai cua QPoint A1(x,y+c); QPoint B1(x,y+2*c/3); QPoint C1(x-r/4,y+2*c/3); QPoint D1(x-r/4,y+c); QPolygon poly2; poly2 << A1 << B1 << C1 << D1; painter.drawPolyline(poly2); // ve cua so QPoint A11(x-r/4,y+c/6); QPoint B11(x-r/4,y); QPoint C11(x-r/8,y); QPoint D11(x-r/8,y+c/12); QPolygon poly21; poly21 << A11 << B11 << C11 << D11; painter.drawPolygon(poly21); painter.drawRect(x+r/4,y+c/2.5,c/10,r/10); }
void graphics::NgoiNhaTiHon(QPainter& painter) { QPoint A(150,450); QPoint B(350,450); QPoint C(350,200); QPoint D(250,100); QPoint E(150,200); QPolygon poly1; poly1 << A << B << C << D << E; painter.drawPolygon(poly1); // cai cua QPoint A1(250,450); QPoint B1(250,300); QPoint C1(200,300); QPoint D1(200,450); QPolygon poly11; poly11 << A1 << B1 << C1 << D1; painter.drawPolygon(poly11); painter.drawRect(300,250,30,30); // ong khoi QPoint A12(200,150); QPoint B12(200,90); QPoint C12(175,90); QPoint D12(175,175); QPolygon poly12; poly12 << A12 << B12 << C12 << D12; painter.drawPolyline(poly12); }
void ViewmdaModel::setC1(int i) { if (m_d1<0) return; if (C1()==i) return; if ((i<0)||(i>=N1())) return; m_current_index[m_d1]=i; emit currentIndexChanged(); }
int sc_main (int argc , char *argv[]) { #ifdef KASCPAR veri_signal<bool> s1; veri_signal<bool> s2; veri_signal<bool> s3; #else sc_core::sc_signal<bool> s1("s1"), s2("s2");//, s3("s3"); #endif Component C1("C1"); Component C2("C2"); // Component C3("C3"); // // superclass* C; // // C = dynamic_cast<superclass*>(&C3); // // superclass* S = C; // // Component* res = dynamic_cast<Component*>(S); C1.out(s1); C2.out(s2); // // (*res).out(s3); // C3.out(s3); C1.in(s2); C2.in(s1); // C3.in(s2); // C1.isHead = true; //Run the Simulation for "200 nanosecnds" sc_start(200, SC_NS); return 0; }
int main(int argc, char** argv){ irqSet(IRQ_VBLANK, &vblank); #ifdef TEXTMODE videoSetMode(MODE_0_2D); videoSetModeSub(MODE_0_2D); vramSetBankA(VRAM_A_MAIN_BG); vramSetBankC(VRAM_C_SUB_BG); #endif//TEXTMODE Display::init(); keysSetRepeat(30, 12); srand(time(NULL)); Player P1(FGrave); Player P2(FMidori); ControlLocal C1(P1); ControlAI C2(P2); //DisplayPlayerOverview a(0, 0, 0, 32, 1, P1); //DisplayContainer b(0, 0, 1, 32, 21, P1.hand()); //DisplayCard c(1, 0, 0, 32, 24, P1.hand().at(0), false); Game(&C1, &C2); while(1){ update(); } return 0; }
// Run a single benchmark for multiplying m x k x n with num_steps of recursion. // To just call GEMM, set num_steps to zero. // The median of five trials is printed to std::cout. // If run_check is true, then it also void SingleBenchmark(int m, int k, int n, int num_steps, int algorithm) { // Run a set number of trials and pick the median time. int num_trials = 1; std::vector<double> times(num_trials); for (int trial = 0; trial < num_trials; ++trial) { Matrix<double> A = RandomMatrix<double>(m, k); Matrix<double> B = RandomMatrix<double>(k, n); Matrix<double> C1(m, n); if (algorithm == SMIRNOV54) { times[trial] = square54_1::FastMatmul(A, B, C1, 3); } else if (algorithm == MKL) { times[trial] = strassen::FastMatmul(A, B, C1, 0); } else if (algorithm == STRASSEN) { times[trial] = strassen::FastMatmul(A, B, C1, num_steps); } else if (algorithm == SCHONHAGE333_21_117_APPROX) { times[trial] = schonhage333_21_117_approx::FastMatmul(A, B, C1, num_steps); } } // Spit out the median time std::sort(times.begin(), times.end()); size_t ind = num_trials / 2; std::cout << " " << m << " " << k << " " << n << " " << num_steps << " " << times[ind] << " " << "; "; }
int test_streams() { // Blog: http://blog.csdn.net/fengbingchun/article/details/76532198 const int length{ 1024 * 1024 * 20}; std::unique_ptr<int[]> A(new int[length]); std::unique_ptr<int[]> B(new int[length]); std::unique_ptr<int[]> C1(new int[length]); std::unique_ptr<int[]> C2(new int[length]); generator_random_number<int>(A.get(), length, -100, 100); generator_random_number<int>(B.get(), length, -100, 100); std::for_each(C1.get(), C1.get() + length, [](int& n) {n = 0; }); std::for_each(C2.get(), C2.get() + length, [](int& n) {n = 0; }); float elapsed_time1{ 0.f }, elapsed_time2{ 0.f }; // milliseconds int ret = streams_cpu(A.get(), B.get(), C1.get(), length, &elapsed_time1); if (ret != 0) PRINT_ERROR_INFO(streams_cpu); ret = streams_gpu(A.get(), B.get(), C2.get(), length, &elapsed_time2); if (ret != 0) PRINT_ERROR_INFO(streams_gpu); for (int i = 0; i < length; ++i) { if (C1[i] != C2[i]) { fprintf(stderr, "their values are different at: %d, val1: %d, val2: %d\n", i, C1[i], C2[i]); return -1; } } fprintf(stderr, "test streams' usage: cpu run time: %f ms, gpu run time: %f ms\n", elapsed_time1, elapsed_time2); return 0; }
bool intersectsRect(Vector2 A, Vector2 B, double x, double y, double width, double height) { Vector2 C0(x, y); Vector2 D0(x + width, y); Vector2 C1(x + width, y); Vector2 D1(x + width, y + height); Vector2 C2(x + width, y + height); Vector2 D2(x, y + height); Vector2 C3(x, y + height); Vector2 D3(x, y); bool I0, I1, I2, I3; Vector2 buf; I0 = intersects(A, B, C0, D0, buf); I1 = intersects(A, B, C1, D1, buf); I2 = intersects(A, B, C2, D2, buf); I3 = intersects(A, B, C3, D3, buf); if(I0 || I1 || I2 || I3) { return false; } return true; }
void inter_sphere(t_caster *caster, t_object *sphere) { double delt; double a; double b; double c; init_temp_pos(caster, sphere); a = A1(caster->temp_vec.x, caster->temp_vec.y, caster->temp_vec.z); b = B1(caster->temp_vec.x, caster->temp_pos.x, caster->temp_vec.y, caster->temp_pos.y, caster->temp_vec.z, caster->temp_pos.z); c = C1(sphere->data.radius, caster->temp_pos.x, caster->temp_pos.y , caster->temp_pos.z); delt = (pow(b, 2.0) - 4.0 * (a * c)); if (delt >= 0.0) { sphere->dist = get_nearest((- b - sqrt(delt)) / (2.0 * a), (- b + sqrt(delt)) / (2.0 * a)); if (sphere->dist > 0.0 && sphere->dist < caster->intersection.dist) { caster->intersection.brightness = sphere->brightness; init_intersection(caster, sphere); rotate_caster(caster, sphere); } } }
double SpinAdapted::StackCreCreDesDes::redMatrixElement(Csf c1, vector<Csf>& ladder, const StackSpinBlock* b) { assert( build_pattern == "(((CC)(D))(D))" ); double element = 0.0; int I = get_orbs()[0]; int J = get_orbs()[1]; int K = get_orbs()[2]; int L = get_orbs()[3]; int Slaterlength = c1.det_rep.begin()->first.size(); vector<bool> backupSlater1(Slaterlength,0), backupSlater2(Slaterlength,0); // Must take into account how the 4-index is built from a combination of the 2-index ops std::vector<SpinQuantum> quantum_ladder = get_quantum_ladder().at("(((CC)(D))(D))"); assert( quantum_ladder.size() == 3 ); SpinQuantum deltaQuantum12 = quantum_ladder.at(0); SpinQuantum deltaQuantum123 = quantum_ladder.at(1); SpinQuantum deltaQuantum1234 = quantum_ladder.at(2); //FIXME components != 0 deltaQuantum[0] = deltaQuantum1234; // Spin quantum data for CC IrrepSpace sym12 = deltaQuantum12.get_symm(); int irrep12 = deltaQuantum12.get_symm().getirrep(); int spin12 = deltaQuantum12.get_s().getirrep(); // Spin quantum data for (CC)D IrrepSpace sym123 = deltaQuantum123.get_symm(); int irrep123 = deltaQuantum123.get_symm().getirrep(); int spin123= deltaQuantum123.get_s().getirrep(); // Spin quantum data for total operator IrrepSpace sym1234 = deltaQuantum1234.get_symm(); int irrep1234 = deltaQuantum1234.get_symm().getirrep(); int spin1234 = deltaQuantum1234.get_s().getirrep(); TensorOp C1(I, 1); TensorOp C2(J, 1); TensorOp D3(K,-1); TensorOp D4(L,-1); TensorOp CC = C1.product(C2, spin12, irrep12); TensorOp CCD = CC.product(D3, spin123, irrep123); TensorOp CCDD = CCD.product(D4, spin1234, irrep1234); //FIXME loop over deltaQuantum components int j = 0; for (int i=0; i<ladder.size(); i++) { int index = 0; double cleb=0.0; if (nonZeroTensorComponent(c1, deltaQuantum[j], ladder[i], index, cleb)) { std::vector<double> MatElements = calcMatrixElements(c1, CCDD, ladder[i], backupSlater1, backupSlater2) ; element = MatElements[index]/cleb; break; } else continue; } return element; }
bool collision(const CircleHitBox &cercleBox1, const CircleHitBox &cercleBox2) { sf::Vector2f C1(cercleBox1.p), C2(cercleBox2.p); float d2 = (C1.x-C2.x)*(C1.x-C2.x) + (C1.y-C2.y)*(C1.y-C2.y); if (d2 > (cercleBox1.rayon + cercleBox2.rayon)*(cercleBox1.rayon + cercleBox2.rayon)) return false; else return true; }
virtual void compute(const vd::Time& t) { f2 = DSAT() * C2(); f1 = C1() * p1; grad(C3) = (f2); grad(C1) = 0 - (f1); grad(DSAT) = 0; grad(C2) = (f1) - (f2); }
void RatioNSDistanceTransform::processRow(const BinaryPixelType *imageRow) { int col; #define N1_SETMINUS_N2_COUNT 1 #define N2_SETMINUS_N1_COUNT 5 #define N1_CAP_N2_COUNT 3 static vect n1[N1_SETMINUS_N2_COUNT] = {{-1, 1}}; static vect n2[N2_SETMINUS_N1_COUNT] = {{1, 0}, {2, 0}, {2, 1}, {1, 2}, {2, 2}}; static vect n12[N1_CAP_N2_COUNT] = {{0, 1}, {1, 1}, {0, 2}}; for (col = 0; col < _cols; col++) { if (imageRow[col] == 0) dtLines[0][col + 2] = 0; else { GrayscalePixelType val; GrayscalePixelType dt; int k; val = GRAYSCALE_MAX; for (k = 0; k < N1_SETMINUS_N2_COUNT; k++) { assert(n1[k].y >= 0); assert(n1[k].y <= 2); assert(col + 2 - n1[k].x >= 0); assert(col + 2 - n1[k].x < _cols + 3); val = std::min(val, dtLines[n1[k].y][col + 2 - n1[k].x]); } assert(C1(d.num, d.den, (int) val) == d.mbf1i(d.mbf1(val)+1)+1); dt = std::min((int)_dMax, d.mbf1i(d.mbf1(val)+1)+1); val = GRAYSCALE_MAX; for (k = 0; k < N2_SETMINUS_N1_COUNT; k++) { assert(n2[k].y >= 0); assert(n2[k].y <= 2); assert(col + 2 - n2[k].x >= 0); assert(col + 2 - n2[k].x < _cols + 3); val = std::min(val, dtLines[n2[k].y][col + 2 - n2[k].x]); } assert(C2(d.num, d.den, (int) val) == d.mbf2i(d.mbf2(val)+1)+1); dt = std::min((int) dt, d.mbf2i(d.mbf2(val)+1)+1); val = GRAYSCALE_MAX; for (k = 0; k < N1_CAP_N2_COUNT; k++) { assert(n12[k].y >= 0); assert(n12[k].y <= 2); assert(col + 2 - n12[k].x >= 0); assert(col + 2 - n12[k].x < _cols + 3); val = std::min(val, dtLines[n12[k].y][col + 2 - n12[k].x]); } dt = std::min((int) dt, val + 1); dtLines[0][col + 2] = dt; } } _consumer->processRow(dtLines[0]+2); rotate(); }
int test_string_cast_vector() { int Error = 0; glm::vec2 A1(1, 2); std::string A2 = glm::to_string(A1); Error += A2 != std::string("fvec2(1.000000, 2.000000)") ? 1 : 0; glm::vec3 B1(1, 2, 3); std::string B2 = glm::to_string(B1); Error += B2 != std::string("fvec3(1.000000, 2.000000, 3.000000)") ? 1 : 0; glm::vec4 C1(1, 2, 3, 4); std::string C2 = glm::to_string(C1); Error += C2 != std::string("fvec4(1.000000, 2.000000, 3.000000, 4.000000)") ? 1 : 0; glm::ivec2 D1(1, 2); std::string D2 = glm::to_string(D1); Error += D2 != std::string("ivec2(1, 2)") ? 1 : 0; glm::ivec3 E1(1, 2, 3); std::string E2 = glm::to_string(E1); Error += E2 != std::string("ivec3(1, 2, 3)") ? 1 : 0; glm::ivec4 F1(1, 2, 3, 4); std::string F2 = glm::to_string(F1); Error += F2 != std::string("ivec4(1, 2, 3, 4)") ? 1 : 0; glm::hvec2 G1(1, 2); std::string G2 = glm::to_string(G1); Error += G2 != std::string("hvec2(1.0000, 2.0000)") ? 1 : 0; glm::hvec3 H1(1, 2, 3); std::string H2 = glm::to_string(H1); Error += H2 != std::string("hvec3(1.0000, 2.0000, 3.0000)") ? 1 : 0; glm::hvec4 I1(1, 2, 3, 4); std::string I2 = glm::to_string(I1); Error += I2 != std::string("hvec4(1.0000, 2.0000, 3.0000, 4.0000)") ? 1 : 0; glm::dvec2 J1(1, 2); std::string J2 = glm::to_string(J1); Error += J2 != std::string("dvec2(1.000000, 2.000000)") ? 1 : 0; glm::dvec3 K1(1, 2, 3); std::string K2 = glm::to_string(K1); Error += K2 != std::string("dvec3(1.000000, 2.000000, 3.000000)") ? 1 : 0; glm::dvec4 L1(1, 2, 3, 4); std::string L2 = glm::to_string(L1); Error += L2 != std::string("dvec4(1.000000, 2.000000, 3.000000, 4.000000)") ? 1 : 0; return Error; }
double SpinAdapted::CreCreCreCre::redMatrixElement(Csf c1, vector<Csf>& ladder, const SpinBlock* b) { assert( build_pattern == "(((CC)(C))(C))" ); double element = 0.0; int I = get_orbs()[0]; int J = get_orbs()[1]; int K = get_orbs()[2]; int L = get_orbs()[3]; // Must take into account how the 4-index is built from a combination of the 2-index ops std::vector<SpinQuantum> quantum_ladder = get_quantum_ladder().at("(((CC)(C))(C))"); assert( quantum_ladder.size() == 3 ); SpinQuantum deltaQuantum12 = quantum_ladder.at(0); SpinQuantum deltaQuantum123 = quantum_ladder.at(1); SpinQuantum deltaQuantum1234 = quantum_ladder.at(2); deltaQuantum[0] = deltaQuantum1234; // Spin quantum data for CC IrrepSpace sym12 = deltaQuantum12.get_symm(); int irrep12 = deltaQuantum12.get_symm().getirrep(); int spin12 = deltaQuantum12.get_s().getirrep(); // Spin quantum data for (CC)C IrrepSpace sym123 = deltaQuantum123.get_symm(); int irrep123 = deltaQuantum123.get_symm().getirrep(); int spin123= deltaQuantum123.get_s().getirrep(); // Spin quantum data for total operator IrrepSpace sym1234 = deltaQuantum1234.get_symm(); int irrep1234 = deltaQuantum1234.get_symm().getirrep(); int spin1234 = deltaQuantum1234.get_s().getirrep(); TensorOp C1(I, 1); TensorOp C2(J, 1); TensorOp C3(K, 1); TensorOp C4(L, 1); TensorOp CC = C1.product(C2, spin12, irrep12); TensorOp CCC = CC.product(C3, spin123, irrep123); TensorOp CCCC = CCC.product(C4, spin1234, irrep1234); for (int i=0; i<ladder.size(); i++) { int index = 0; double cleb=0.0; if (nonZeroTensorComponent(c1, deltaQuantum[0], ladder[i], index, cleb)) { std::vector<double> MatElements = calcMatrixElements(c1, CCCC, ladder[i]) ; element = MatElements[index]/cleb; break; } else continue; } return element; }
void testConstructor2() { MRR stdfRec; stdfRec["DISP_COD"]=C1('M'); TS_ASSERT_EQUALS(stdfRec.storage(), 7u); std::vector<std::basic_string<char> > str; stdfRec.to_string(str); TS_ASSERT_EQUALS(str[0], "7"); TS_ASSERT_EQUALS(str[1], "1"); TS_ASSERT_EQUALS(str[2], "20"); TS_ASSERT_EQUALS(str[3], "0"); TS_ASSERT_EQUALS(str[4], "M"); }
Molecule C2H4() { int nAtoms = 6; Eigen::Vector3d C1(0.0000000000, 0.0000000000, 1.2578920000); Eigen::Vector3d H1(0.0000000000, 1.7454620000, 2.3427160000); Eigen::Vector3d H2(0.0000000000, -1.7454620000, 2.3427160000); Eigen::Vector3d C2(0.0000000000, 0.0000000000, -1.2578920000); Eigen::Vector3d H3(0.0000000000, 1.7454620000, -2.3427160000); Eigen::Vector3d H4(0.0000000000, -1.7454620000, -2.3427160000); Eigen::MatrixXd geom(3, nAtoms); geom.col(0) = C1.transpose(); geom.col(1) = H1.transpose(); geom.col(2) = H2.transpose(); geom.col(3) = C2.transpose(); geom.col(4) = H3.transpose(); geom.col(5) = H4.transpose(); Eigen::VectorXd charges(6), masses(6); charges << 6.0, 1.0, 1.0, 6.0, 1.0, 1.0; masses << 12.00, 1.0078250, 1.0078250, 12.0, 1.0078250, 1.0078250; double radiusC = (1.70 * 1.20) / convertBohrToAngstrom; double radiusH = (1.20 * 1.20) / convertBohrToAngstrom; std::vector<Atom> atoms; atoms.push_back( Atom("Carbon", "C", charges(0), masses(0), radiusC, C1, 1.0) ); atoms.push_back( Atom("Hydrogen", "H", charges(1), masses(1), radiusH, H1, 1.0) ); atoms.push_back( Atom("Hydrogen", "H", charges(2), masses(2), radiusH, H2, 1.0) ); atoms.push_back( Atom("Carbon", "C", charges(3), masses(3), radiusC, C2, 1.0) ); atoms.push_back( Atom("Hydrogen", "H", charges(4), masses(4), radiusH, H3, 1.0) ); atoms.push_back( Atom("Hydrogen", "H", charges(5), masses(5), radiusH, H4, 1.0) ); std::vector<Sphere> spheres; Sphere sph1(C1, radiusC); Sphere sph2(H1, radiusH); Sphere sph3(H2, radiusH); Sphere sph4(C2, radiusC); Sphere sph5(H3, radiusH); Sphere sph6(H4, radiusH); spheres.push_back(sph1); spheres.push_back(sph2); spheres.push_back(sph3); spheres.push_back(sph4); spheres.push_back(sph5); spheres.push_back(sph6); // D2h as generated by Oxy, Oxz, Oyz Symmetry pGroup = buildGroup(3, 4, 2, 1); return Molecule(nAtoms, charges, masses, geom, atoms, spheres, pGroup); };
BOOL CARIB8CharDecode::Analyze( const BYTE* pbSrc, DWORD dwSrcSize, DWORD* pdwReadSize ) { if( pbSrc == NULL || dwSrcSize == 0 || pdwReadSize == NULL){ return FALSE; } BOOL bRet = TRUE; DWORD dwReadSize = 0; while( dwReadSize < dwSrcSize ){ DWORD dwReadBuff = 0; //1バイト目チェック if( pbSrc[dwReadSize] <= 0x20 ){ //C0制御コード bRet = C0( pbSrc+dwReadSize, &dwReadBuff ); dwReadSize += dwReadBuff; if( bRet == FALSE ){ return FALSE; }else if( bRet == 2 ){ bRet = TRUE; break; } }else if( pbSrc[dwReadSize] > 0x20 && pbSrc[dwReadSize] < 0x7F ){ //GL符号領域 if( GL( pbSrc+dwReadSize, &dwReadBuff ) == FALSE ){ return FALSE; } dwReadSize += dwReadBuff; }else if( pbSrc[dwReadSize] >= 0x7F && pbSrc[dwReadSize] <= 0xA0 ){ //C1制御コード bRet = C1( pbSrc+dwReadSize, &dwReadBuff ); dwReadSize += dwReadBuff; if( bRet == FALSE ){ return FALSE; }else if( bRet == 2 ){ bRet = TRUE; break; } }else if( pbSrc[dwReadSize] > 0xA0 && pbSrc[dwReadSize] < 0xFF ){ //GR符号領域 if( GR( pbSrc+dwReadSize, &dwReadBuff ) == FALSE ){ return FALSE; } dwReadSize += dwReadBuff; } } *pdwReadSize = dwReadSize; return bRet; }
inline void subtractMultipleTo(DMatQQ& C, const DMatQQ& A, const DMatQQ& B) { FlintQQMat A1(A); FlintQQMat B1(B); FlintQQMat C1(C); FlintQQMat result1(A.numRows(), B.numColumns()); FlintQQMat D1(A.numRows(), B.numColumns()); fmpq_mat_mul(D1.value(), A1.value(), B1.value()); fmpq_mat_sub(C1.value(), C1.value(), D1.value()); C1.toDMat(C); }
inline void addMultipleTo(DMatZZGMP& C, const DMatZZGMP& A, const DMatZZGMP& B) { FlintZZMat A1(A); FlintZZMat B1(B); FlintZZMat C1(C); FlintZZMat result1(A.numRows(), B.numColumns()); FlintZZMat D1(A.numRows(), B.numColumns()); fmpz_mat_mul(D1.value(), A1.value(), B1.value()); fmpz_mat_add(C1.value(), C1.value(), D1.value()); C1.toDMat(C); }
void Foam::maxwellSlipUFvPatchVectorField::updateCoeffs() { if (updated()) { return; } const fvPatchScalarField& pmu = patch().lookupPatchField<volScalarField, scalar>(muName_); const fvPatchScalarField& prho = patch().lookupPatchField<volScalarField, scalar>(rhoName_); const fvPatchField<scalar>& ppsi = patch().lookupPatchField<volScalarField, scalar>(psiName_); Field<scalar> C1 ( sqrt(ppsi*constant::mathematical::piByTwo) * (2.0 - accommodationCoeff_)/accommodationCoeff_ ); Field<scalar> pnu(pmu/prho); valueFraction() = (1.0/(1.0 + patch().deltaCoeffs()*C1*pnu)); refValue() = Uwall_; if (thermalCreep_) { const volScalarField& vsfT = this->db().objectRegistry::lookupObject<volScalarField>(TName_); label patchi = this->patch().index(); const fvPatchScalarField& pT = vsfT.boundaryField()[patchi]; Field<vector> gradpT(fvc::grad(vsfT)().boundaryField()[patchi]); vectorField n(patch().nf()); refValue() -= 3.0*pnu/(4.0*pT)*transform(I - n*n, gradpT); } if (curvature_) { const fvPatchTensorField& ptauMC = patch().lookupPatchField<volTensorField, tensor>(tauMCName_); vectorField n(patch().nf()); refValue() -= C1/prho*transform(I - n*n, (n & ptauMC)); } mixedFixedValueSlipFvPatchVectorField::updateCoeffs(); }
int main(int argc, char **argv) { int m = 8000; int k = 3600; int n = 3600; int numsteps = 1; Matrix<double> A = RandomMatrix<double>(m, k); Matrix<double> B = RandomMatrix<double>(k, n); Matrix<double> C1(m, n), C2(m, n); Time([&] { MatMul(A, B, C1); }, "Classical gemm"); Time([&] { grey433_29_234::FastMatmul(A, B, C2, numsteps); }, "Fast (4, 3, 3)"); // Test for correctness. std::cout << "Maximum relative difference: " << MaxRelativeDiff(C1, C2) << std::endl; return 0; }
/*! * @param rxn Reaction index of the current reaction. This is used * as an index into vectors which have length n_total_rxn. * @param k This is a vector of integer values specifying the * species indices. The length of this vector species * the number of different species in the description. * The value of the entries are the species indices. * These are used as indexes into vectors which have * length n_total_species. * @param order This is a vector of the same length as vector k. * The order is used for the routine power(), which produces * a power law expression involving the species vector. * @param stoich This is used to handle fractional stoichiometric coefficients * on the product side of irreversible reactions. */ void StoichManagerN::add(size_t rxn, const std::vector<size_t>& k, const vector_fp& order, const vector_fp& stoich) { //printf ("add called\n"); if (order.size() != k.size()) { throw CanteraError("StoichManagerN::add()", "size of order and species arrays differ"); } if (stoich.size() != k.size()) { throw CanteraError("StoichManagerN::add()", "size of stoich and species arrays differ"); } bool frac = false; for (size_t n = 0; n < stoich.size(); n++) { if (fmod(stoich[n], 1.0) || fmod(order[n], 1.0)) { frac = true; break; } } if (frac || k.size() > 3) { m_cn_list.push_back(C_AnyN(rxn, k, order, stoich)); } else { // Try to express the reaction with unity stoichiometric // coefficients (by repeating species when necessary) so that the // simpler 'multiply' function can be used to compute the rate // instead of 'power'. std::vector<size_t> kRep; for (size_t n = 0; n < k.size(); n++) { for (size_t i = 0; i < stoich[n]; i++) kRep.push_back(k[n]); } switch (kRep.size()) { case 1: m_c1_list.push_back(C1(rxn, kRep[0])); break; case 2: m_c2_list.push_back(C2(rxn, kRep[0], kRep[1])); break; case 3: m_c3_list.push_back(C3(rxn, kRep[0], kRep[1], kRep[2])); break; default: m_cn_list.push_back(C_AnyN(rxn, k, order, stoich)); } } }