C++ (Cpp) infinity_norm Examples

Example #1

File: test_mymath.c Project: kaneshin/mathematical-optimization

void
test_infinity_norm(void) {
    /* double
     * infinity_norm(
     *     const double *x,
     *     int n
     * ); */
    int i;

    for (i = 0; i < n; ++i) {
        x[i] = 0.;
        y[i] = 0.;
    }
    x[5] = 1.;
    y[1] = -2.;
    CU_ASSERT_EQUAL(1., infinity_norm(x, n));
    CU_ASSERT_EQUAL(2., infinity_norm(y, n));
}

Example #2

File: oldExpcuda.c Project: aabdelaz/blackScholes

// a is the matrix you have, e is the one you'll fill in
void padeExp(float *A, float *E, int n) {
    culaStatus status;
    float s;
    float *Q;
    float *I;	
    float *A2;
    float *P;
    int i, j, f, *piv, scaled = 0;
    float c[POL + 1];

    c[0] = 1;
    for (i = 0; i < POL; i++) {
      	c[i + 1] = c[i]*((double)(POL - i)/((i + 1)*(2*POL - i)));
    } 
    
    // scale here
    s = infinity_norm(A, n);
    if (s > 0.5) {
        scaled = 1;
        f = (int) (log(s)/log(2));  
        s = MAX(0,f + 2);
        status = culaSgemm('n', 'n', n, n, n, 0, A, n, A, n, pow(2, -s), A, n);
        checkCulaStatus(status);
    }

    // set up identity
    I = (float*)malloc(n*n*sizeof(float));
    memset(I, 0, n*n*sizeof(float));
    for (i = 0; i < n; i++) {
        I[i*n + i] = 1;
    }
    
    Q = (float*)malloc(n*n*sizeof(float));
    P = (float*)malloc(n*n*sizeof(float));
    memcpy(Q, I, n*n*sizeof(float));
    memcpy(P, I, n*n*sizeof(float));
    
    // allocate space for A2; no need to initialize memory
    A2 = (float*)malloc(n*n*sizeof(float));
 
    status = culaSgemm('n', 'n', n, n, n, 1, A, n, A, n, 0, A2, n);
    checkCulaStatus(status);

    status = culaSgemm('n', 'n', n, n, n, 0, Q, n, Q, n, c[POL], Q, n); 
    checkCulaStatus(status);
    status = culaSgemm('n', 'n', n, n, n, 0, P, n, P, n, c[POL - 1], P, n); 
    checkCulaStatus(status);

    int odd = 1;
    for (i = POL - 2; i >= 0; i--) {
        if (odd == 1) {
            // Q = Q*A2 + c[k]*I;
            status = culaSgemm('n', 'n', n, n, n, 1, Q, n, A2, n, 0, Q, n); 
            checkCulaStatus(status);
            
            status = culaSgemm('n', 'n', n, n, n, c[i], I, n, I, n, 1, Q, n); 
            checkCulaStatus(status); 
        }
        else {
            // P = P*A2 + c[k]*I 
            status = culaSgemm('n', 'n', n, n, n, 1, P, n, A2, n, 0, P, n); 
            checkCulaStatus(status);
            
            status = culaSgemm('n', 'n', n, n, n, c[i], I, n, I, n, 1, P, n); 
            checkCulaStatus(status);
        }
        
        odd = 1-odd;
  	}  

  	if (odd == 1) {
    	// Q = Q*A
    	status = culaSgemm('n', 'n', n, n, n, 1, Q, n, A, n, 0, Q, n); 
    	checkCulaStatus(status);
  	}
  	else {
    	// P = P*A
    	status = culaSgemm('n', 'n', n, n, n, 1, P, n, A, n, 0, P, n); 
    	checkCulaStatus(status);
  	}
  
  	// Q = Q - P
  	status = culaSgemm('n', 'n', n, n, n, -1, P, n, I, n, 1, Q, n); 
  	checkCulaStatus(status);

  	// Find X s.t. QX = P
  	piv = (int*)malloc(n*sizeof(int));
  	memset(piv, 0, n*sizeof(int));
  
  	status = culaSgesv(n, n, Q, n, piv, P, n);
  	checkCulaStatus(status);
  
  	// now P = X
 
  	memcpy(E, I, n*n*sizeof(float));
  	if (odd == 0) status = culaSgemm('n', 'n', n, n, n, 2, I, n, P, n, 1, E, n);
  	else status = culaSgemm('n', 'n', n, n, n, -2, I, n, P, n, -1, E, n);
  
  	checkCulaStatus(status);

  	for(i = 0; i < s; i++) {
    	status = culaSgemm('n', 'n', n, n, n, 1, E, n, E, n, 0, E, n);
        checkCulaStatus(status);
    }


    if (scaled == 1) {
        status = culaSgemm('n', 'n', n, n, n, 0, A, n, A, n, 1./pow(2, -s), A, n);
        checkCulaStatus(status);
    }

    free(I);
    free(A2);
    free(P);
    free(Q);
    free(piv);
    return;
}