// only c1 and c2 can be modified static void interact(const struct cell *c1, const struct cell *c2) { if (is_leaf(c1) && is_leaf(c2)) { direct(c1, c2); } else if (is_leaf(c1)) { map(interact, product(c1, get_subcells(c2))); } else if (is_leaf(c2)) { map(interact, product(get_subcells(c1), c2)); } else { map(interact, product(get_subcells(c1), get_subcells(c2))); } }
void normalize_vec4(vec4 *v) { scalar n; /* normalize v */ product(v, v, &n); if ((n != (scalar) 0.0) && (n != (scalar)1.0)) { n = (scalar)1.0 / sqrtf(n); product(&n, v, v); } }
Poly power(Poly P, LL n, const Poly &coef) { Poly ret(P.size()); ret[0] = 1; while (n) { if (n & 1) ret = product(ret, P, coef); P = product(P, P, coef); n >>= 1; } return ret; }
long double multinomialSamplingProb(const vector<long double>& probs, const vector<int>& obs) { vector<long double> factorials; vector<long double> probsPowObs; factorials.resize(obs.size()); transform(obs.begin(), obs.end(), factorials.begin(), factorial); vector<long double>::const_iterator p = probs.begin(); vector<int>::const_iterator o = obs.begin(); for (; p != probs.end() && o != obs.end(); ++p, ++o) { probsPowObs.push_back(pow(*p, *o)); } return factorial(sum(obs)) / product(factorials) * product(probsPowObs); }
v3 v3::transform_4(mat44 t_mat){ colvec4 operand = {x, y, z, c}; colvec4 product = t_mat * operand; // if (product(3) == -7 && c==1){ // std::cout << "operand --" << std::endl; // operand.print(); // std::cout << "product --" << std::endl; // product.print(); // std::cout << "t_mat --" <<std::endl; // t_mat.print(); // } return v3(product(0), product(1), product(2), product(3)); }
int main(int argc, char *argv[]) { FILE* output; double a[nmax], b[nmax], c[nmax]; double sa, sb, sc, max; int na, nb, nc; int minval, maxval; setlocale(LC_ALL, "rus"); // Проверки на правильность введенных аргументов if (argc < 6) { fprintf(stderr, "Недостаточно параметров!\n"); return -1; } if (!sscanf(argv[1], "%d", &minval)){ fprintf(stderr, "1-ый и 2-ой аргумент должны представлять минимальную и максимальную границу диапозона, соответственно.\n"); return -2; } if (!sscanf(argv[2], "%d", &maxval)){ fprintf(stderr, "1-ый и 2-ой аргумент должны представлять минимальную и максимальную границу диапозона, соответственно.\n"); return -3; } if (minval >= maxval){ fprintf(stderr, "Пустой диапозон.\n"); return -4; } if ((output = fopen(s_output, "w")) == NULL) { fprintf(stderr, "Невозможно создать файл '%s'\n", s_output); return -5; } // Вывод диапазона fprintf(output, "Диапазон: %d - %d\n", minval, maxval); // Ввод массивов из файлов if (!ArrayInput(&na, a, argv[3], &fclose)) return -5; if (!ArrayInput(&nb, b, argv[4], &fclose)) return -6; if (!ArrayInput(&nc, c, argv[5], &fclose)) return -7; // Умножение элементов, выходящих за границы sa = product(a, na, minval, maxval, &check); sb = product(b, nb, minval, maxval, &check); sc = product(c, nc, minval, maxval, &check); // Поиск максимального значения max = sa; if (sb > max) max = sb; if (sc > max) max = sc; // Вывод результатов if (sa == max) fprintf(output, "Массив А имеет максимальное произведение элементов: %9.3lf\n", max); if (sb == max) fprintf(output, "Массив B имеет максимальное произведение элементов: %9.3lf\n", max); if (sc == max) fprintf(output, "Массив C имеет максимальное произведение элементов: %9.3lf\n", max); }
bool Interval::intersect_soft (Interval tmp) { if ((product(tmp.s).sign() == product(tmp.e).sign() && (product(tmp.s)).sign() != 0) || (tmp.product(s).sign() == (tmp.product(e)).sign() && (tmp.product(s)).sign() != 0)) return false; if (product(tmp.s).sign() == product(tmp.e).sign() && (product(tmp.s)).sign() == 0) { Fraction max1; Fraction max2; Fraction min1; Fraction min2; if(s.getX() != e.getX()) { max1 = (s.getX() <= e.getX() ? e.getX() : s.getX()); max2 = (s.getX() <= e.getX() ? e.getX() : s.getX()); min1 = (s.getX() <= e.getX() ? s.getX() : e.getX()); min2 = (s.getX() <= e.getX() ? e.getX() : s.getX()); } else { max1 = (s.getY() <= e.getY() ? e.getY() : s.getY()); max2 = (s.getY() <= e.getY() ? e.getY() : s.getY()); min1 = (s.getY() <= e.getY() ? s.getY() : e.getY()); min2 = (s.getY() <= e.getY() ? e.getY() : s.getY()); } return (max1 >= min2 && max2 >= min1); } if(product(tmp.s).sign() != product(tmp.e).sign() && tmp.product(s).sign() != (tmp.product(e)).sign()) return true; return false; }
char *sum(void){ char *var1, *var2; var1 = product(); while(match(PLUS)){ advance(); var2 = product(); //printf("%s = %s + %s\n", var1,var1,var2); //printf("ADD %s, %s\n", var2,var1); fprintf(f,"ADD %s, %s\n", var2,var1); freename(var2); } return var1; }
static u32 InvMixCol(u32 x) { /* matrix Multiplication */ u32 y,m; u8 b[4]; m=pack(InCo); b[3]=product(m,x); m=ROTL24(m); b[2]=product(m,x); m=ROTL24(m); b[1]=product(m,x); m=ROTL24(m); b[0]=product(m,x); y=pack(b); return y; }
/*列混合的逆变换*/ static WORD InvMixCol(WORD x) { /* matrix Multiplication */ WORD y,m; BYTE b[4]; m=pack(InCo); b[3]=product(m,x); m=ROTL24(m); b[2]=product(m,x); m=ROTL24(m); b[1]=product(m,x); m=ROTL24(m); b[0]=product(m,x); y=pack(b); return y; }
int main() { FILE *in = fopen("ride.in", "r"); FILE *out = fopen("ride.out", "w"); char comet[LEN], group[LEN]; fscanf(in, "%s\n%s", comet, group); fprintf(out, "%s\n", (product(comet)%47 == product(group)%47) ? "GO" : "STAY"); fclose(in); fclose(out); return 0; }
void CLyapWolfMethod::orthonormalize() { if (mNumExp < 1) return; //TODO generalize C_FLOAT64 *dbl, *dblEnd; dbl = mVariables.array() + mSystemSize; dblEnd = dbl + mSystemSize; mNorms[0] = norm(dbl, dblEnd); scalarmult(dbl, dblEnd, 1 / mNorms[0]); size_t i, j; for (i = 1; i < mNumExp; ++i) { dbl += mSystemSize; dblEnd = dbl + mSystemSize; //orthogonalisation for (j = 0; j < i; ++j) { add(dbl, dblEnd, -product(dbl, dblEnd, mVariables.array() + (j + 1)*mSystemSize), mVariables.array() + (j + 1)*mSystemSize); } //normalisation mNorms[i] = norm(dbl, dblEnd); scalarmult(dbl, dblEnd, 1 / mNorms[i]); } }
template<class T> static bool load_nc_array(const NcFile& ncf, const string& name, vector<T>& dest, bool required = true, int offset = 0, int count = -1) { NcVar *v = load_nc_variable(ncf, name.c_str(), required); if (v) { vector<long> offsets = list_of(offset).repeat(v->num_dims()-1, 0); v->set_cur(&offsets.front()); vector<long> counts (v->num_dims()); long* shape = v->edges(); transform(shape, shape + v->num_dims(), offsets.begin(), counts.begin(), minus<long>()); delete shape; if (count > 0) { counts[0] = count; } dest.resize(product(counts)); bool success = v->get(&dest.front(), &counts.front()); if (!success) { dest.resize(0); check(!required, string("NetcdfDataset::load_nc_array<") + typeid(T).name() + "> " + name + '\n' + "failed with offset " + str(offsets) + ", counts " + str(counts)); } return success; } return false; }
/** * @param A: Given an integers array A * @return: A long long array B and B[i]= A[0] * ... * A[i-1] * A[i+1] * ... * A[n-1] */ vector<long long> productExcludeItself(vector<int> &nums) { if (nums.size() < 2) { return vector<long long>(); } vector<long long> left_product(nums.size()); vector<long long> right_product(nums.size()); vector<long long> product(nums.size()); left_product[0] = 1; for (int i = 1; i < nums.size(); ++i) { left_product[i] = left_product[i - 1] * nums[i - 1]; } right_product[nums.size() - 1] = 1; for (int j = nums.size() - 2; j >= 0; --j) { right_product[j] = right_product[j + 1] * nums[j + 1]; } for (int k = 0; k < nums.size(); ++k) { product[k] = left_product[k] * right_product[k]; } return product; }
UMatrix<T>& UMatrix<T> :: operator*(const T mult) { // if(m_dimension != source.m_dimension) throw Exception(5); UMatrix<T> product(m_dimension); for(int i=0; i<m_dimension; i++) { for(int j=0; j<m_dimension-i; j++) { product(i,j) = m_ptr_to_data[i][j] * mult; } } copy(product); return *this; }
bool init_fb(const struct grid_info grid) { bool ret = true; if (grid.stages & GL_COMPUTE_SHADER_BIT) { const struct image_info img = image_info_for_grid(grid); const unsigned n = product(grid.size) * image_num_components(grid.format); uint32_t *pixels = malloc(n * sizeof(*pixels)); ret = init_pixels(img, pixels, 0.5, 0.5, 0.5, 0.5) && upload_image(img, max_image_units(), pixels); free(pixels); } else { ret = generate_fb(grid, 0); glClearColor(0.5, 0.5, 0.5, 0.5); glClear(GL_COLOR_BUFFER_BIT); glClearDepth(0.5); glClear(GL_DEPTH_BUFFER_BIT); } return ret; }
vector<vector<int>> multiply(vector<vector<int>>& A, vector<vector<int>>& B) { int row1 = A.size(); int col1 = A[0].size(); int row2 = B.size(); int col2 = B[0].size(); vector<vector<int>> product(row1, vector<int>(col2, 0)); for(int i = 0; i < row1; i++) { bool zeroRow = true; for(int p = 0; p < col1; ++p) { if(A[i][p] != 0) { zeroRow = false; break; } } if(zeroRow) continue; for(int j = 0; j < col2; ++j) { bool zeroCol = true; for(int q = 0; q < row2; ++q) { if(B[q][j] != 0) { zeroCol = false; break; } } if(zeroCol) continue; for(int k = 0; k < col1; ++k) { if(A[i][k] == 0 or B[k][j] == 0) continue; product[i][j] += (A[i][k] * B[k][j]); } } } return product; }
int main(int argc, char const *argv[]) { int pro; pro=product(5,1,2,3,4,5); printf("%d\n",pro ); return 0; }
int main() { float a, b, r; char op; do { printf("Extra line of code --- \n"); printf("Number operator Number: "); scanf(" %f %c %f", &a, &op, &b); switch (op) { case '+' : r = add(a,b); break; case '*' : r = product(a,b); break; case '-' : r = subtract(a,b); break; case '/' : r = divide(a,b); break; case '%' : r = remainder(a,b); break; case 'q' : break; default : op='?'; } if (op=='?') printf("Unknown operator\n"); else if (op=='q') printf("Bye\n"); else printf("%f %c %f = %f\n", a, op, b, r); } while (op != 'q'); return 0; }
int main(int argc, char *argv[]) { int fds[2] = {0}; int th = 0; int ret = pipe(fds); if (ret < 0) { printf("pipe failed\n"); return -1; } th = fork(); if (th < 0) { printf("fork failed\n"); return -1; } else if (th == 0) { product(fds); } else { consumer(fds); } wait(NULL); return 0; }
void product(int choices, int repeat, int*& arr, int level) { int len = pow(choices, repeat); if(level == 0) { arr = new int[len * repeat]; } int mod = pow(choices, level); for(int a = 0; a < len; a++) { int b = (a - (a % mod))/mod % choices; //printf("%i ", b); arr[a*repeat + level] = b; } //printf("\n"); if(level < (repeat-1)) { product(choices, repeat, arr, level + 1); } /* if(level == 0) { for(int a = 0; a < len; a++) { for(int b = 0; b < repeat; b++) { printf("%i ",arr[a*repeat + b]); } printf("\n"); } } */ }
int main() { int t, n, m; matrix A, B, F; A.a1 = 1; A.a2 = 1; A.a3 = 1; A.a4 = 0; F.a1 = 6; F.a2 = 4; F.a3 = 4; F.a4 = 2; LL delta; scanf("%d", &t); while(t--) { scanf("%d", &n); scanf("%d", &m); if(n == 0) { printf("0\n"); continue; } else if(n == 1) { printf("1\n"); continue; } B = get_exp(A, n-1, m); B = product(B, F, m); delta = ((n+2) / m + 1) * m; printf("%lld\n", (B.a2 + delta-n-2) % m); } return 0; }
string multiply(string num1, string num2) { int i, j; int m = num1.size(), n = num2.size(); // max (m + n) digits vector<int> product(m + n, 0); string result; // reverse for ease of calc reverse(num1.begin(), num1.end()); reverse(num2.begin(), num2.end()); // digit i * digit j contributes to digit i + j for (i = 0; i < m; i++) { for (j = 0; j < n; j++) { product[i + j] += (num1[i] - '0') * (num2[j] - '0'); product[i + j + 1] += product[i + j] / 10; product[i + j] %= 10; } } // remove leading 0; keep last 0 if all 0 for (i = m + n - 1; i > 0 && 0 == product[i]; i--) ; for (; i >= 0; i--) result += to_string(product[i]); return result; }
void vctDeterminantTest::TestDeterminant2x2ByInverse(const vctFixedSizeMatrix<ElementType, 2, 2> & inputMatrix) { const ElementType determinant = vctDeterminant<2>::Compute(inputMatrix); const ElementType tolerance = cmnTypeTraits<ElementType>::Tolerance(); if (fabs(determinant) < tolerance) { vctFixedSizeVector<ElementType, 2> rowRatio; rowRatio.ElementwiseRatioOf( inputMatrix.Row(0), inputMatrix.Row(1) ); CPPUNIT_ASSERT_DOUBLES_EQUAL( rowRatio[0], rowRatio[1], tolerance ); vctFixedSizeVector<ElementType, 2> columnRatio; columnRatio.ElementwiseRatioOf( inputMatrix.Column(0), inputMatrix.Column(1) ); CPPUNIT_ASSERT_DOUBLES_EQUAL( columnRatio[0], columnRatio[1], tolerance ); return; } const vctFixedSizeMatrix<ElementType, 2, 2> inverse( inputMatrix[1][1] / determinant, -inputMatrix[0][1] / determinant, -inputMatrix[1][0] / determinant, inputMatrix[0][0] / determinant ); /* gcc (Ubuntu 4.4.3-4ubuntu5) 4.4.3 crashes with internal error on ubuntu 64 - Ubuntu 10.04.1 LTS with const */ /* const */ vctFixedSizeMatrix<ElementType, 2, 2> product( inputMatrix * inverse ); const vctFixedSizeMatrix<ElementType, 2, 2> identity( ElementType(1), ElementType(0), ElementType(0), ElementType(1) ); const vctFixedSizeMatrix<ElementType, 2, 2> difference = product - identity; ElementType diffNorm = difference.Norm(); CPPUNIT_ASSERT_DOUBLES_EQUAL( 0, diffNorm, tolerance ); }
inline field_polynomial& field_polynomial::operator*=(const field_polynomial& polynomial) { if (field_ == polynomial.field_) { field_polynomial product(field_,deg() + polynomial.deg() + 1); poly_iter result_it = product.poly_.begin(); for (poly_iter it0 = poly_.begin(); it0 != poly_.end(); ++it0) { poly_iter current_result_it = result_it; for (const_poly_iter it1 = polynomial.poly_.begin(); it1 != polynomial.poly_.end(); ++it1) { (*current_result_it) += (*it0) * (*it1); ++current_result_it; } ++result_it; } simplify(product); poly_ = product.poly_; } return *this; }
Fraction Fraction::operator*(const Fraction &arg) { Fraction product(_numerator * arg._numerator, _denominator * arg._denominator); cancel(product); return product; }
bigInt multiplyBigInt(bigInt a, bigInt b){ bigInt product("0"); bigInt greater("0"); bigInt lesser("0"); if (b.num.size() > a.num.size()){ // Find vector with most elements greater = b; lesser = a; } else{ greater = a; lesser = b; } product.num.resize(a.num.size() + b.num.size()); // Get the magnitude of the product product.bigIntInit(); int k = 0; for (unsigned long i = 0; i < lesser.num.size(); i++){ // By hand style multiplacation for (unsigned long j = 0; j < greater.num.size(); j++){ product.num[j + k] += greater.num[j] * lesser.num[i]; } k++; } product.cleanCarries(); if (a.isNegative != b.isNegative){ product.isNegative = 1; } return product; }
static bool is_test_reasonable(bool quick, const struct image_extent size) { /* Set an arbitrary limit on the number of texels so the test * doesn't take forever. */ return product(size) < (quick ? 4 : 64) * 1024 * 1024; }
void invert_mat4(mat4 *m, mat4 *n) { scalar d = det(m); if (d == (scalar)0.0) return; /* Cofactor matrix */ (*n)[0] = _det_mat3((*m)[5], (*m)[6], (*m)[7], (*m)[9], (*m)[10], (*m)[11], (*m)[13], (*m)[14], (*m)[15]); (*n)[1] = - _det_mat3((*m)[1], (*m)[2], (*m)[3], (*m)[9], (*m)[10], (*m)[11], (*m)[13], (*m)[14], (*m)[15]); (*n)[2] = _det_mat3((*m)[1], (*m)[2], (*m)[3], (*m)[5], (*m)[6], (*m)[7], (*m)[13], (*m)[14], (*m)[15]); (*n)[3] = - _det_mat3((*m)[1], (*m)[2], (*m)[3], (*m)[5], (*m)[6], (*m)[7], (*m)[9], (*m)[10], (*m)[11]); (*n)[4] = - _det_mat3((*m)[4], (*m)[6], (*m)[7], (*m)[8], (*m)[10], (*m)[11], (*m)[12], (*m)[14], (*m)[15]); (*n)[5] = _det_mat3((*m)[0], (*m)[2], (*m)[3], (*m)[8], (*m)[10], (*m)[11], (*m)[12], (*m)[14], (*m)[15]); (*n)[6] = - _det_mat3((*m)[0], (*m)[2], (*m)[3], (*m)[4], (*m)[6], (*m)[7], (*m)[12], (*m)[14], (*m)[15]); (*n)[7] = _det_mat3((*m)[0], (*m)[2], (*m)[3], (*m)[4], (*m)[6], (*m)[7], (*m)[8], (*m)[10], (*m)[11]); (*n)[8] = _det_mat3((*m)[4], (*m)[5], (*m)[7], (*m)[8], (*m)[9], (*m)[11], (*m)[12], (*m)[13], (*m)[15]); (*n)[9] = - _det_mat3((*m)[0], (*m)[1], (*m)[3], (*m)[8], (*m)[9], (*m)[11], (*m)[12], (*m)[13], (*m)[15]); (*n)[10] = _det_mat3((*m)[0], (*m)[1], (*m)[3], (*m)[4], (*m)[5], (*m)[7], (*m)[12], (*m)[13], (*m)[15]); (*n)[11] = - _det_mat3((*m)[0], (*m)[1], (*m)[3], (*m)[4], (*m)[5], (*m)[7], (*m)[8], (*m)[9], (*m)[11]); (*n)[12] = - _det_mat3((*m)[4], (*m)[5], (*m)[6], (*m)[8], (*m)[9], (*m)[10], (*m)[12], (*m)[13], (*m)[14]); (*n)[13] = _det_mat3((*m)[0], (*m)[1], (*m)[2], (*m)[8], (*m)[9], (*m)[10], (*m)[12], (*m)[13], (*m)[14]); (*n)[14] = - _det_mat3((*m)[0], (*m)[1], (*m)[2], (*m)[4], (*m)[5], (*m)[6], (*m)[12], (*m)[13], (*m)[14]); (*n)[15] = _det_mat3((*m)[0], (*m)[1], (*m)[2], (*m)[4], (*m)[5], (*m)[6], (*m)[8], (*m)[9], (*m)[10]); if (d != (scalar)1.0) { d = ((scalar)1.0)/d; product(&d, n, n); } }
int main(){ //double **x = malloc(a * sizeof *x + (a * (b * sizeof **x))); //double **y = malloc(b * sizeof *y + (b * (c * sizeof **y))); //double **z = malloc(a * sizeof *z + (a * (c * sizeof **z))); int size1 = a*b*sizeof(double); int size2 = b*c*sizeof(double); int size3 = a*c*sizeof(double); double *x = (double*)malloc(size1); double *y = (double*)malloc(size2); double *z = (double*)malloc(size3); fillMatrix(x,a,b); fillMatrix(y,b,c); clock_t begin, end; double time_spent; begin = clock(); product(x,y,z); end = clock(); time_spent = (double)(end - begin) / CLOCKS_PER_SEC; printf("%lf\n", time_spent); //print(z,a,c); //print(z,a,c); }