ll sk_sum(ll k){
ll d=0, kk, sum, i;
if(k<1) return 0;
for(kk=k;kk;kk/=10)
d++;
sum=0;
for(i=1;i<d;++i){
sum+=vec_sum(expand(i-1),expand(i)-1,i,suffix(i));
}
sum+=vec_sum(expand(d-1),k,d,suffix(d));
return sum;
}
/**
* Main function
*
* @param argc
* @param argv
*/
int main(int argc, char **argv)
{
// create PAPI routines
PapiCounterList papi_routines;
papi_routines.AddRoutine("matvec");
// allocate arrays
float a[ROWS][COLS];
float b[COLS];
float c[ROWS] = {0.0f};
printf("Rows: %d\n", ROWS);
printf("Cols: %d\n", COLS);
printf("Runs: %d\n", RUNS);
// initialize matrix & vector
mat_init(ROWS, COLS, 1.0, a);
vec_init(COLS, 3.0, b);
// do the measurement
papi_routines["matvec"].Start();
for (unsigned i = 0; i < RUNS; i++)
mat_vec_mul(ROWS, COLS, a, b, c);
papi_routines["matvec"].Stop();
// print results
printf("Control sum: %f\n", vec_sum(ROWS, c));
printf("\n");
papi_routines.PrintScreen();
return EXIT_SUCCESS;
}
void normalize(double *x, int len) {
int i;
double sum;
sum = vec_sum(x, len);
if(sum <= 0.0) fprintf(stderr, "sum not positive\n");
for(i=0;i<len;i++) x[i] /= sum;
}
/* Transpose matrix B to both:
*
* - increase cache hits
* - simd GCC vector extensions which is made possible.
* by the transposition, to increase likelyhood of SIMDs.
*
* Note that GCC 6 O=3 is smart enough to use SIMD
* even for the naive CPU method. However this was still way faster.
* */
void mat_mul_cpu_trans_vec(const F *A, const F *B, F *C, size_t n, Cache *cache) {
F tmpf;
size_t i, j, k, k_max, ai, bi;
Vec tmp, a, b;
UNUSED(cache);
mat_trans((F*)B, n);
k_max = (n / VECTOR_NELEMS) * VECTOR_NELEMS;
for (i = 0; i < n; ++i) {
for (j = 0; j < n; ++j) {
vec_zero(&tmp, VECTOR_NELEMS);
for (k = 0; k < k_max; k += VECTOR_NELEMS) {
ai = i * n + k;
bi = j * n + k;
vec_load(&a, VECTOR_NELEMS, A, ai);
vec_load(&b, VECTOR_NELEMS, B, bi);
tmp += a * b;
}
tmpf = 0.0;
for (; k < n; ++k) {
tmpf += A[i*n+k] * B[j*n+k];
}
C[i*n+j] = vec_sum(tmp, VECTOR_NELEMS) + tmpf;
}
}
mat_trans((F*)B, n);
}
double plane_t::hits(
vec_t *base, /* ray base */
vec_t *dir) /* unit direction vector */
{
double ndotd;
double t;
double ndotb;
ndotq = vec_dot(&normal, &point);
ndotd = vec_dot(dir, &normal);
/* ndotd = 0 -> ray is parallel to the plane */
if (ndotd == 0)
return(-1);
ndotb = vec_dot(&normal, base);
t = (ndotq - ndotb) / ndotd;
if (t <= 0)
return(-1);
vec_scale(t, dir, &hitloc);
vec_sum(&hitloc, base, &hitloc);
if (hitloc.z > 0.001)
return(-1);
return(t);
}
double plane_t::hits(vec_t *base, vec_t* dir){
double ndotd;
double t;
double ndotb;
ndotq = vec_dot(&normal, &point);
ndotd = vec_dot(dir, &normal);
/* ndotd = 0 -> ray is parallel to the plane */
if (ndotd == 0)
return(-1);
ndotb = vec_dot(&normal, base);
t = (ndotq - ndotb) / ndotd;
if (t <= 0)
return(-1);
vec_scale(t, dir, &last_hitpt);
vec_sum(&last_hitpt, base, &last_hitpt);
if ((last_hitpt.z > 0.01) && (strcmp(obj_type, "projector")))
return(-1);
return(t);
}
/**
* Main function
*
* @param argc
* @param argv
*/
int main(int argc, char **argv)
{
// allocate matrix
float *A = (float*)_mm_malloc(ROWS * COLS * sizeof(float), 64);
if(A == NULL)
{
fprintf(stderr, "_mm_malloc error !\n");
return EXIT_FAILURE;
}
// allocate vectors
float *B = (float*)_mm_malloc(COLS * sizeof(float), 64);
if(A == NULL)
{
fprintf(stderr, "_mm_malloc error !\n");
_mm_free(A);
return EXIT_FAILURE;
}
float *C = (float*)_mm_malloc(ROWS * sizeof(float), 64);
if(A == NULL)
{
fprintf(stderr, "_mm_malloc error !\n");
_mm_free(A);
_mm_free(B);
return EXIT_FAILURE;
}
printf("Rows: %d\n", ROWS);
printf("Cols: %d\n", COLS);
printf("Runs: %d\n", RUNS);
// initialize matrix & vector
const double tstart = omp_get_wtime();
mat_init(ROWS, COLS, 1.0, A);
vec_init(COLS, 3.0, B);
const double tinit = omp_get_wtime();
// do the measurement
for(unsigned i = 0; i < RUNS; i++)
{
mat_vec_mul(ROWS, COLS, A, B, C);
}
const double tcalc = omp_get_wtime();
// print results
printf("Control sum: %f\n", vec_sum(ROWS, C));
printf("Time Initialization: %0.3f\n", tinit - tstart);
printf("Time Calculation: %0.3f\n", tcalc - tinit);
printf("Time Total: %0.3f\n", tcalc - tstart);
// free memory
_mm_free(A);
_mm_free(B);
_mm_free(C);
return EXIT_SUCCESS;
}
double log_sum(double *x, int len) {
int i;
double res, sum;
sum = vec_max(x, len);
for(i=0;i<len;i++) x[i] -= sum;
for(i=0;i<len;i++) x[i] = exp(x[i]);
res = vec_sum(x, len);
return res;
}
void mat_sum_cols(Matrix m, double *sum)
{
int xi,yi;
double *p=m.dat;
for (yi=0; yi<m.ny; yi++,p+=m.nx)
{
sum[yi]=vec_sum(p,m.nx);
}
}
float DOWHAM::square_diff(const float *a, const float *b, const int &sizea, const int &sizeb)
{
if (sizeb != sizeb)
{
std::cerr << "\nERROR! Size of vectors do not match, cannot find the square difference\n" << std::endl;
std::exit(1);
}
std::vector<float> difference(sizea);
for (int i=0; i<sizea; i++)
{
difference[i] = (a[i]-b[i])*(a[i]-b[i]);
}
return vec_sum(difference);
}
void next_position(int *steps)
{
double newp[MAX_DIM];
double err[MAX_DIM];
int i;
tim += 1.0;
vec_mul_scalar(newp, incvec, tim);
vec_sum(newp, newp, origin);
vec_diff(err, newp, position);
for (i = 0; i < MAX_DIM; i++) {
steps[i] = (int)err[i];
position[i] += (double)steps[i];
}
}
double sample_lambda_laplace(const gsl_rng *random, double *beta,
int dk_rows, int *dk_rowbreaks, int *dk_cols, double *deltak,
double a, double b)
{
double *x;
double lambda;
x = (double *) malloc(dk_rows * sizeof(double));
mat_dot_vec(dk_rows, dk_rowbreaks, dk_cols, deltak, beta, x);
vec_abs(dk_rows, x);
lambda = gsl_ran_gamma(random, a+dk_rows, 1.0 / (b + vec_sum(dk_rows, x)));
free(x);
return lambda;
}
/*
* @brief Calls a certian loop method which possibly
* optimizes the loopig procedure. Which method is chosen
* depends on the variant variable.
*
* @param variant determines which loop optimization
* is chosen. A non-zero number calls a compiler
* supported variant with pragma unroll(variant).
* Negative numbers choose a method which manually
* unrolls a loop without any compiler based opt-ins.
* -1 No manualy unrolling
* -2 manualy unrolling 2 values per loop step
* -3 manualy unrolling 3 values per loop step
* -4 manualy unrolling 4 values per loop step
* -8 manualy unrolling 8 values per loop step
*
*/
static double callback(int variant, GRID_T *vec, int nmemb){
double ret = 0;
switch(variant){
case 1:
ret = vec_sumOpt0(vec, nmemb);
break;
case 2:
ret = vec_sumOpt2(vec, nmemb);
break;
case 3:
ret = vec_sumOpt3(vec, nmemb);
break;
case 4:
ret = vec_sumOpt4(vec, nmemb);
break;
case 8:
ret = vec_sumOpt8(vec, nmemb);
break;
case -1:
ret = vec_sum(vec, nmemb);
break;
case -2:
ret = vec_sum2(vec, nmemb);
break;
case -3:
ret = vec_sum3(vec, nmemb);
break;
case -4:
ret = vec_sum4(vec, nmemb);
break;
case -8:
ret = vec_sum8(vec, nmemb);
break;
}
return ret;
}
double sample_lambda_doublepareto2(const gsl_rng *random, double *beta,
int dk_rows, int *dk_rowbreaks, int *dk_cols, double *deltak,
double a, double b, double gamma, double *tau)
{
int i;
double *x;
double lambda;
x = (double *) malloc(dk_rows * sizeof(double));
/* Sample the global lambda parameter */
lambda = gsl_ran_gamma(random, a + gamma * dk_rows, 1.0 / (b + vec_sum(dk_rows, tau)));
/* Sample the local tau parameters */
mat_dot_vec(dk_rows, dk_rowbreaks, dk_cols, deltak, beta, x);
vec_abs(dk_rows, x);
for (i = 0; i < dk_rows; i++){
tau[i] = gsl_ran_gamma(random, gamma+1, 1.0 / (x[i] + lambda));
}
free(x);
return lambda;
}
void ATL_USERMM
(const int M, const int N, const int K, const float alpha, const float *A, const int lda, const float *B, const int ldb, const float beta, float *C, const int ldc)
{
/*--- program info ---*/
/* $Revision: 1.3 $ */
/* loadfirst = 'a' */
/* nu = 1 */
/* k_loop = None */
/* problem = 'gemm' */
/* nregs = 8 */
/* split = 0 */
/* n_cleanup = {} */
/* mu = 2 */
/* ku = 4 */
/* rev = '$Revision: 1.3 $' */
/* applyfilter = 0 */
/* align_jumps = 0 */
/* prec = 'single' */
/* m_cleanup = {} */
/* used_outside_len = 60 */
/* k_cleanup = {'mustfit': 56, 'method': 'acc1', 'compile': 1} */
/* outputdir = 'Linux_PIII/' */
/* arch = 'sse' */
/* pipelength = 3 */
/* atlasname = 'Linux_PIII' */
/* method = 'acc' */
/* used_lastuse = 'b' */
/* outside_len = 60 */
/* lastuse = 1 */
/* veclen = 4 */
/* sched = ['fuse', 'spread'] */
/* used_directload_b = 0 */
/* used_directload_a = 1 */
/*--- achitecture specific declarations ---*/
/*--- program specific declarations ---*/
int i, j, k;
vector betavec;
vector zerovec = {0.0,0.0,0.0,0.0};
const float *pA0 = A;
const float *pB0 = B;
float *pC0 = C;
const float *stM = A + MB*KB;
const float *stN = B + NB*KB;
const int incAm = 2*KB-KB+60;
const int incBm = -KB+60;
const int incCm = (2 SHIFT);
const int incAn = -MB*KB;
const int incBn = 1*KB;
const int incCn = ((ldc*1-MB) SHIFT);
/*--- initial arhitecture specific statements ---*/
/*--- main program statements ---*/
vec_mov_mr_1(&beta,reg0);
vec_mov_rm(reg0,betavec);
do /* N-loop */
{
do /* M-loop */
{
#ifdef BETA0
vec_mov_mr(zerovec,reg7);
vec_mov_rr(reg7,reg0);
vec_mov_rr(reg7,reg1);
#elif defined(BETA1)
vec_mov_mr_1(pC0,reg0);
vec_mov_mr_1(pC0+(1 SHIFT),reg1);
#else
vec_mov_mr(betavec,reg7);
vec_mov_mr_1(pC0,reg0);
vec_mul_rr(reg7,reg0);
vec_mov_mr_1(pC0+(1 SHIFT),reg1);
vec_mul_rr(reg7,reg1);
#endif
vec_mov_mr_a(pB0,reg5);
vec_mov_mr_a(pA0,reg2);
vec_mul_rr(reg5,reg2);
vec_add_rr(reg2,reg0);
vec_mul_mr_a(pA0+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_mr_a(pB0+4,reg6);
vec_mov_mr_a(pA0+4,reg3);
vec_mul_rr(reg6,reg3);
vec_add_rr(reg3,reg0);
vec_mul_mr_a(pA0+4+KB,reg6);
vec_add_rr(reg6,reg1);
vec_mov_mr_a(pB0+8,reg7);
vec_mov_mr_a(pA0+8,reg4);
vec_mul_rr(reg7,reg4);
vec_add_rr(reg4,reg0);
vec_mul_mr_a(pA0+8+KB,reg7);
vec_add_rr(reg7,reg1);
vec_mov_mr_a(pB0+12,reg5);
vec_mov_mr_a(pA0+12,reg2);
vec_mul_rr(reg5,reg2);
vec_add_rr(reg2,reg0);
vec_mul_mr_a(pA0+12+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_mr_a(pB0+16,reg6);
vec_mov_mr_a(pA0+16,reg3);
vec_mul_rr(reg6,reg3);
vec_add_rr(reg3,reg0);
vec_mul_mr_a(pA0+16+KB,reg6);
vec_add_rr(reg6,reg1);
vec_mov_mr_a(pB0+20,reg7);
vec_mov_mr_a(pA0+20,reg4);
vec_mul_rr(reg7,reg4);
vec_add_rr(reg4,reg0);
vec_mul_mr_a(pA0+20+KB,reg7);
vec_add_rr(reg7,reg1);
vec_mov_mr_a(pB0+24,reg5);
vec_mov_mr_a(pA0+24,reg2);
vec_mul_rr(reg5,reg2);
vec_add_rr(reg2,reg0);
vec_mul_mr_a(pA0+24+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_mr_a(pB0+28,reg6);
vec_mov_mr_a(pA0+28,reg3);
vec_mul_rr(reg6,reg3);
vec_add_rr(reg3,reg0);
vec_mul_mr_a(pA0+28+KB,reg6);
vec_add_rr(reg6,reg1);
vec_mov_mr_a(pB0+32,reg7);
vec_mov_mr_a(pA0+32,reg4);
vec_mul_rr(reg7,reg4);
vec_add_rr(reg4,reg0);
vec_mul_mr_a(pA0+32+KB,reg7);
vec_add_rr(reg7,reg1);
vec_mov_mr_a(pB0+36,reg5);
vec_mov_mr_a(pA0+36,reg2);
vec_mul_rr(reg5,reg2);
vec_add_rr(reg2,reg0);
vec_mul_mr_a(pA0+36+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_mr_a(pB0+40,reg6);
vec_mov_mr_a(pA0+40,reg3);
vec_mul_rr(reg6,reg3);
vec_add_rr(reg3,reg0);
vec_mul_mr_a(pA0+40+KB,reg6);
vec_add_rr(reg6,reg1);
vec_mov_mr_a(pB0+44,reg7);
vec_mov_mr_a(pA0+44,reg4);
vec_mul_rr(reg7,reg4);
vec_add_rr(reg4,reg0);
vec_mul_mr_a(pA0+44+KB,reg7);
vec_add_rr(reg7,reg1);
vec_mov_mr_a(pB0+48,reg5);
vec_mov_mr_a(pA0+48,reg2);
vec_mul_rr(reg5,reg2);
vec_add_rr(reg2,reg0);
vec_mul_mr_a(pA0+48+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_mr_a(pB0+52,reg6);
vec_mov_mr_a(pA0+52,reg3);
vec_mul_rr(reg6,reg3);
vec_add_rr(reg3,reg0);
vec_mul_mr_a(pA0+52+KB,reg6);
vec_add_rr(reg6,reg1);
vec_mov_mr_a(pB0+56,reg5);
vec_mov_mr_a(pA0+56,reg2);
vec_mul_rr(reg5,reg2);
vec_add_rr(reg2,reg0);
vec_mul_mr_a(pA0+56+KB,reg5);
vec_add_rr(reg5,reg1);
vec_sum(reg0);
vec_sum(reg1);
vec_mov_rm_1(reg0,pC0);
vec_mov_rm_1(reg1,pC0+(1 SHIFT));
pA0 += incAm;
pB0 += incBm;
pC0 += incCm;
}
while(pA0 != stM);
pA0 += incAn;
pB0 += incBn;
pC0 += incCn;
}
while(pB0 != stN);
}
void ATL_USERMM
(const int M, const int N, const int K, const float alpha, const float *A, const int lda, const float *B, const int ldb, const float beta, float *C, const int ldc)
{
/*--- program info ---*/
/* $Revision: 1.3 $ */
/* loadfirst = 'b' */
/* nu = 1 */
/* k_loop = None */
/* problem = 'gemm_m' */
/* nregs = 8 */
/* split = 1 */
/* n_cleanup = {} */
/* mu = 4 */
/* ku = 16 */
/* rev = '$Revision: 1.3 $' */
/* applyfilter = 0 */
/* align_jumps = 0 */
/* prec = 'single' */
/* m_cleanup = {} */
/* used_outside_len = 112 */
/* k_cleanup = {} */
/* outputdir = 'Linux_P4/' */
/* arch = 'sse' */
/* pipelength = 3 */
/* atlasname = 'Linux_P4' */
/* method = 'acc' */
/* used_lastuse = None */
/* used_directload_a = 1 */
/* outside_len = 112 */
/* veclen = 4 */
/* sched = ['spread', 'fuse'] */
/* used_directload_b = 0 */
/* lastuse = 0 */
/*--- achitecture specific declarations ---*/
/*--- program specific declarations ---*/
int i, j, k;
vector betavec;
vector zerovec = {0.0,0.0,0.0,0.0};
const float *pA0 = A;
const float *pB0 = B;
float *pC0 = C;
const float *stM = A + (M-M%4)*KB;
const float *stN = B + NB*KB;
const int incAm = 4*KB-KB+112;
const int incBm = -KB+112;
const int incCm = (4 SHIFT);
const int incAn = -(M-M%4)*KB;
const int incBn = 1*KB;
const int incCn = ((ldc*1-(M-M%4)) SHIFT);
const int incAm_m = KB-KB+112;
const int incAn_m = -(M%4)*KB;
const int incCn_m = (ldc*1-(M%4))SHIFT;
const float *stM_m = A + M*KB;
/*--- initial arhitecture specific statements ---*/
/*--- main program statements ---*/
vec_mov_mr_1(&beta,reg0);
vec_mov_rm(reg0,betavec);
if (M>=4)
{
do /* N-loop */
{
do /* M-loop */
{
#ifdef BETA0
vec_mov_mr(zerovec,reg7);
vec_mov_rr(reg7,reg0);
vec_mov_rr(reg7,reg1);
vec_mov_rr(reg7,reg2);
vec_mov_rr(reg7,reg3);
#elif defined(BETA1)
vec_mov_mr_1(pC0,reg0);
vec_mov_mr_1(pC0+(1 SHIFT),reg1);
vec_mov_mr_1(pC0+(2 SHIFT),reg2);
vec_mov_mr_1(pC0+(3 SHIFT),reg3);
#else
vec_mov_mr(betavec,reg7);
vec_mov_mr_1(pC0,reg0);
vec_mul_rr(reg7,reg0);
vec_mov_mr_1(pC0+(1 SHIFT),reg1);
vec_mul_rr(reg7,reg1);
vec_mov_mr_1(pC0+(2 SHIFT),reg2);
vec_mul_rr(reg7,reg2);
vec_mov_mr_1(pC0+(3 SHIFT),reg3);
vec_mul_rr(reg7,reg3);
#endif
vec_mov_mr_a(pB0,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+4,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+4,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+4+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+4+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+4+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+8,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+8,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+8+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+8+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+8+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+12,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+12,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+12+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+12+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+12+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+16,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+16,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+16+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+16+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+16+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+20,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+20,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+20+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+20+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+20+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+24,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+24,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+24+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+24+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+24+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+28,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+28,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+28+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+28+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+28+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+32,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+32,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+32+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+32+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+32+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+36,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+36,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+36+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+36+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+36+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+40,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+40,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+40+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+40+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+40+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+44,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+44,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+44+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+44+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+44+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+48,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+48,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+48+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+48+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+48+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+52,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+52,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+52+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+52+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+52+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+56,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+56,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+56+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+56+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+56+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+60,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+60,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+60+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+60+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+60+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+64,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+64,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+64+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+64+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+64+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+68,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+68,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+68+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+68+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+68+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+72,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+72,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+72+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+72+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+72+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+76,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+76,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+76+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+76+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+76+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+80,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+80,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+80+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+80+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+80+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+84,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+84,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+84+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+84+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+84+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+88,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+88,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+88+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+88+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+88+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+92,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+92,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+92+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+92+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+92+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+96,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+96,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+96+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+96+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+96+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+100,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+100,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+100+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+100+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+100+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+104,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+104,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+104+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+104+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+104+3*KB,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pB0+108,reg7);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+108,reg4);
vec_add_rr(reg4,reg0);
vec_mov_rr(reg7,reg5);
vec_mul_mr_a(pA0+108+KB,reg5);
vec_add_rr(reg5,reg1);
vec_mov_rr(reg7,reg6);
vec_mul_mr_a(pA0+108+2*KB,reg6);
vec_add_rr(reg6,reg2);
vec_mov_rr(reg7,reg4);
vec_mul_mr_a(pA0+108+3*KB,reg4);
vec_add_rr(reg4,reg3);
#ifndef TCPLX
vec_sum_full(reg0,reg1,reg2,reg3,reg5,reg6,reg7);
vec_mov_rm(reg5,pC0);
#else
vec_sum(reg0);
vec_sum(reg1);
vec_sum(reg2);
vec_sum(reg3);
vec_mov_rm_1(reg0,pC0);
vec_mov_rm_1(reg1,pC0+(1 SHIFT));
vec_mov_rm_1(reg2,pC0+(2 SHIFT));
vec_mov_rm_1(reg3,pC0+(3 SHIFT));
#endif
pA0 += incAm;
pB0 += incBm;
pC0 += incCm;
}
while(pA0 != stM);
pA0 += incAn;
pB0 += incBn;
pC0 += incCn;
}
while(pB0 != stN);
}
if (M%4>0)
{
pC0 = C+((M-M%4)SHIFT);
pA0 = A+(M-M%4)*KB;
pB0 = B;
do /* N-loop */
{
do /* M-loop */
{
#ifdef BETA0
vec_mov_mr(zerovec,reg7);
vec_mov_rr(reg7,reg0);
#elif defined(BETA1)
vec_mov_mr_1(pC0,reg0);
#else
vec_mov_mr(betavec,reg7);
vec_mov_mr_1(pC0,reg0);
vec_mul_rr(reg7,reg0);
#endif
vec_mov_mr_a(pB0,reg1);
vec_mul_mr_a(pA0,reg1);
vec_add_rr(reg1,reg0);
vec_mov_mr_a(pB0+4,reg2);
vec_mul_mr_a(pA0+4,reg2);
vec_add_rr(reg2,reg0);
vec_mov_mr_a(pB0+8,reg3);
vec_mul_mr_a(pA0+8,reg3);
vec_add_rr(reg3,reg0);
vec_mov_mr_a(pB0+12,reg1);
vec_mul_mr_a(pA0+12,reg1);
vec_add_rr(reg1,reg0);
vec_mov_mr_a(pB0+16,reg2);
vec_mul_mr_a(pA0+16,reg2);
vec_add_rr(reg2,reg0);
vec_mov_mr_a(pB0+20,reg3);
vec_mul_mr_a(pA0+20,reg3);
vec_add_rr(reg3,reg0);
vec_mov_mr_a(pB0+24,reg1);
vec_mul_mr_a(pA0+24,reg1);
vec_add_rr(reg1,reg0);
vec_mov_mr_a(pB0+28,reg2);
vec_mul_mr_a(pA0+28,reg2);
vec_add_rr(reg2,reg0);
vec_mov_mr_a(pB0+32,reg3);
vec_mul_mr_a(pA0+32,reg3);
vec_add_rr(reg3,reg0);
vec_mov_mr_a(pB0+36,reg1);
vec_mul_mr_a(pA0+36,reg1);
vec_add_rr(reg1,reg0);
vec_mov_mr_a(pB0+40,reg2);
vec_mul_mr_a(pA0+40,reg2);
vec_add_rr(reg2,reg0);
vec_mov_mr_a(pB0+44,reg3);
vec_mul_mr_a(pA0+44,reg3);
vec_add_rr(reg3,reg0);
vec_mov_mr_a(pB0+48,reg1);
vec_mul_mr_a(pA0+48,reg1);
vec_add_rr(reg1,reg0);
vec_mov_mr_a(pB0+52,reg2);
vec_mul_mr_a(pA0+52,reg2);
vec_add_rr(reg2,reg0);
vec_mov_mr_a(pB0+56,reg3);
vec_mul_mr_a(pA0+56,reg3);
vec_add_rr(reg3,reg0);
vec_mov_mr_a(pB0+60,reg1);
vec_mul_mr_a(pA0+60,reg1);
vec_add_rr(reg1,reg0);
vec_mov_mr_a(pB0+64,reg2);
vec_mul_mr_a(pA0+64,reg2);
vec_add_rr(reg2,reg0);
vec_mov_mr_a(pB0+68,reg3);
vec_mul_mr_a(pA0+68,reg3);
vec_add_rr(reg3,reg0);
vec_mov_mr_a(pB0+72,reg1);
vec_mul_mr_a(pA0+72,reg1);
vec_add_rr(reg1,reg0);
vec_mov_mr_a(pB0+76,reg2);
vec_mul_mr_a(pA0+76,reg2);
vec_add_rr(reg2,reg0);
vec_mov_mr_a(pB0+80,reg3);
vec_mul_mr_a(pA0+80,reg3);
vec_add_rr(reg3,reg0);
vec_mov_mr_a(pB0+84,reg1);
vec_mul_mr_a(pA0+84,reg1);
vec_add_rr(reg1,reg0);
vec_mov_mr_a(pB0+88,reg2);
vec_mul_mr_a(pA0+88,reg2);
vec_add_rr(reg2,reg0);
vec_mov_mr_a(pB0+92,reg3);
vec_mul_mr_a(pA0+92,reg3);
vec_add_rr(reg3,reg0);
vec_mov_mr_a(pB0+96,reg1);
vec_mul_mr_a(pA0+96,reg1);
vec_add_rr(reg1,reg0);
vec_mov_mr_a(pB0+100,reg2);
vec_mul_mr_a(pA0+100,reg2);
vec_add_rr(reg2,reg0);
vec_mov_mr_a(pB0+104,reg3);
vec_mul_mr_a(pA0+104,reg3);
vec_add_rr(reg3,reg0);
vec_mov_mr_a(pB0+108,reg1);
vec_mul_mr_a(pA0+108,reg1);
vec_add_rr(reg1,reg0);
vec_sum(reg0);
vec_mov_rm_1(reg0,pC0);
pA0 += incAm_m;
pB0 += incBm;
pC0 += (1 SHIFT);
}
while(pA0 != stM_m);
pA0 += incAn_m;
pB0 += incBn;
pC0 += incCn_m;
}
while(pB0 != stN);
}
}
void ATL_USERMM
(const int M, const int N, const int K, const float alpha, const float *A, const int lda, const float *B, const int ldb, const float beta, float *C, const int ldc)
{
/*--- achitecture specific declarations ---*/
/*--- program specific declarations ---*/
int i, j, k;
vector betavec;
vector zerovec = {0.0,0.0};
const float *pA0 = A;
const float *pB0 = B;
float *pC0 = C;
float *pC1 = C+(ldc SHIFT);
const float *stM = A + (M-M%2)*KB;
const float *stN = B + NB*KB;
const int incAm = 2*KB-KB+4;
const int incBm = -KB+4;
const int incCm = (2 SHIFT);
const int incAn = -(M-M%2)*KB;
const int incBn = 2*KB;
const int incCn = ((ldc*2-(M-M%2)) SHIFT);
const int incAm_m = KB-KB+4;
const int incAn_m = -(M%2)*KB;
const int incCn_m = (ldc*2-(M%2))SHIFT;
const float *stM_m = A + M*KB;
/*--- initial arhitecture specific statements ---*/
vec_enter();
/*--- main program statements ---*/
vec_mov_mr_1(&beta,reg0);
vec_mov_rm(reg0,betavec);
if (M>=2)
{
do /* N-loop */
{
do /* M-loop */
{
#ifdef BETA0
vec_zero(reg0);
vec_zero(reg1);
vec_zero(reg2);
vec_zero(reg3);
#elif defined(BETA1)
vec_mov_mr_1(pC0,reg0);
vec_mov_mr_1(pC0+(1 SHIFT),reg1);
vec_mov_mr_1(pC1,reg2);
vec_mov_mr_1(pC1+(1 SHIFT),reg3);
#else
vec_mov_mr(betavec,reg7);
vec_mov_mr_1(pC0,reg0);
vec_mul_rr(reg7,reg0);
vec_mov_mr_1(pC0+(1 SHIFT),reg1);
vec_mul_rr(reg7,reg1);
vec_mov_mr_1(pC1,reg2);
vec_mul_rr(reg7,reg2);
vec_mov_mr_1(pC1+(1 SHIFT),reg3);
vec_mul_rr(reg7,reg3);
#endif
vec_mov_mr(pA0,reg4);
vec_mul_mr(pB0,reg4);
vec_mov_mr(pA0+KB,reg5);
vec_mul_mr(pB0,reg5);
vec_mov_mr(pA0,reg6);
vec_mov_mr(pA0+KB,reg7);
align();
for (k=0; k<KB-4; k+=16)
{
vec_add_rr(reg4,reg0);
vec_mov_mr(pA0+2,reg4);
vec_mul_mr(pB0+KB,reg6);
vec_add_rr(reg5,reg1);
vec_mov_mr(pA0+2+KB,reg5);
vec_mul_mr(pB0+KB,reg7);
vec_add_rr(reg6,reg2);
vec_mov_mr(pA0+2,reg6);
vec_mul_mr(pB0+2,reg4);
vec_add_rr(reg7,reg3);
vec_mov_mr(pA0+2+KB,reg7);
vec_mul_mr(pB0+2,reg5);
vec_add_rr(reg4,reg0);
vec_mov_mr(pA0+4,reg4);
vec_mul_mr(pB0+2+KB,reg6);
vec_add_rr(reg5,reg1);
vec_mov_mr(pA0+4+KB,reg5);
vec_mul_mr(pB0+2+KB,reg7);
vec_add_rr(reg6,reg2);
vec_mov_mr(pA0+4,reg6);
vec_mul_mr(pB0+4,reg4);
vec_add_rr(reg7,reg3);
vec_mov_mr(pA0+4+KB,reg7);
vec_mul_mr(pB0+4,reg5);
vec_add_rr(reg4,reg0);
vec_mov_mr(pA0+6,reg4);
vec_mul_mr(pB0+4+KB,reg6);
vec_add_rr(reg5,reg1);
vec_mov_mr(pA0+6+KB,reg5);
vec_mul_mr(pB0+4+KB,reg7);
vec_add_rr(reg6,reg2);
vec_mov_mr(pA0+6,reg6);
vec_mul_mr(pB0+6,reg4);
vec_add_rr(reg7,reg3);
vec_mov_mr(pA0+6+KB,reg7);
vec_mul_mr(pB0+6,reg5);
vec_add_rr(reg4,reg0);
vec_mov_mr(pA0+8,reg4);
vec_mul_mr(pB0+6+KB,reg6);
vec_add_rr(reg5,reg1);
vec_mov_mr(pA0+8+KB,reg5);
vec_mul_mr(pB0+6+KB,reg7);
vec_add_rr(reg6,reg2);
vec_mov_mr(pA0+8,reg6);
vec_mul_mr(pB0+8,reg4);
vec_add_rr(reg7,reg3);
vec_mov_mr(pA0+8+KB,reg7);
vec_mul_mr(pB0+8,reg5);
vec_add_rr(reg4,reg0);
vec_mov_mr(pA0+10,reg4);
vec_mul_mr(pB0+8+KB,reg6);
vec_add_rr(reg5,reg1);
vec_mov_mr(pA0+10+KB,reg5);
vec_mul_mr(pB0+8+KB,reg7);
vec_add_rr(reg6,reg2);
vec_mov_mr(pA0+10,reg6);
vec_mul_mr(pB0+10,reg4);
vec_add_rr(reg7,reg3);
vec_mov_mr(pA0+10+KB,reg7);
vec_mul_mr(pB0+10,reg5);
vec_add_rr(reg4,reg0);
vec_mov_mr(pA0+12,reg4);
vec_mul_mr(pB0+10+KB,reg6);
vec_add_rr(reg5,reg1);
vec_mov_mr(pA0+12+KB,reg5);
vec_mul_mr(pB0+10+KB,reg7);
vec_add_rr(reg6,reg2);
vec_mov_mr(pA0+12,reg6);
vec_mul_mr(pB0+12,reg4);
vec_add_rr(reg7,reg3);
vec_mov_mr(pA0+12+KB,reg7);
vec_mul_mr(pB0+12,reg5);
vec_add_rr(reg4,reg0);
vec_mov_mr(pA0+14,reg4);
vec_mul_mr(pB0+12+KB,reg6);
vec_add_rr(reg5,reg1);
vec_mov_mr(pA0+14+KB,reg5);
vec_mul_mr(pB0+12+KB,reg7);
vec_add_rr(reg6,reg2);
vec_mov_mr(pA0+14,reg6);
vec_mul_mr(pB0+14,reg4);
vec_add_rr(reg7,reg3);
vec_mov_mr(pA0+14+KB,reg7);
vec_mul_mr(pB0+14,reg5);
vec_add_rr(reg4,reg0);
vec_mov_mr(pA0+16,reg4);
vec_mul_mr(pB0+14+KB,reg6);
vec_add_rr(reg5,reg1);
vec_mov_mr(pA0+16+KB,reg5);
vec_mul_mr(pB0+14+KB,reg7);
vec_add_rr(reg6,reg2);
vec_mov_mr(pA0+16,reg6);
vec_mul_mr(pB0+16,reg4);
vec_add_rr(reg7,reg3);
vec_mov_mr(pA0+16+KB,reg7);
vec_mul_mr(pB0+16,reg5);
pA0 += 16;
pB0 += 16;
}
vec_add_rr(reg4,reg0);
vec_mov_mr(pA0+2,reg4);
vec_mul_mr(pB0+KB,reg6);
vec_add_rr(reg5,reg1);
vec_mov_mr(pA0+2+KB,reg5);
vec_mul_mr(pB0+KB,reg7);
vec_add_rr(reg6,reg2);
vec_mov_mr(pA0+2,reg6);
vec_mul_mr(pB0+2,reg4);
vec_add_rr(reg7,reg3);
vec_mov_mr(pA0+2+KB,reg7);
vec_mul_mr(pB0+2,reg5);
vec_add_rr(reg4,reg0);
vec_add_rr(reg5,reg1);
vec_mul_mr(pB0+2+KB,reg6);
vec_add_rr(reg6,reg2);
vec_mul_mr(pB0+2+KB,reg7);
vec_add_rr(reg7,reg3);
vec_sum(reg0);
vec_sum(reg1);
vec_sum(reg2);
vec_sum(reg3);
vec_mov_rm_1(reg0,pC0);
vec_mov_rm_1(reg1,pC0+(1 SHIFT));
vec_mov_rm_1(reg2,pC1);
vec_mov_rm_1(reg3,pC1+(1 SHIFT));
pA0 += incAm;
pB0 += incBm;
pC0 += incCm;
pC1 += incCm;
}
while(pA0 != stM);
pA0 += incAn;
pB0 += incBn;
pC0 += incCn;
pC1 += incCn;
}
while(pB0 != stN);
}
if (M%2>0)
{
pC0 = C+((M-M%2)SHIFT);
pC1 = C+(ldc SHIFT)+((M-M%2)SHIFT);
pA0 = A+(M-M%2)*KB;
pB0 = B;
do /* N-loop */
{
do /* M-loop */
{
#ifdef BETA0
vec_zero(reg0);
vec_zero(reg1);
#elif defined(BETA1)
vec_mov_mr_1(pC0,reg0);
vec_mov_mr_1(pC1,reg1);
#else
vec_mov_mr(betavec,reg7);
vec_mov_mr_1(pC0,reg0);
vec_mul_rr(reg7,reg0);
vec_mov_mr_1(pC1,reg1);
vec_mul_rr(reg7,reg1);
#endif
vec_mov_mr(pA0,reg6);
align();
for (k=0; k<KB-4; k+=16)
{
vec_mov_rr(reg6,reg2);
vec_mul_mr(pB0,reg2);
vec_mov_rr(reg6,reg3);
vec_mov_mr(pA0+2,reg6);
vec_mul_mr(pB0+KB,reg3);
vec_add_rr(reg2,reg0);
vec_add_rr(reg3,reg1);
vec_mov_rr(reg6,reg2);
vec_mul_mr(pB0+2,reg2);
vec_mov_rr(reg6,reg3);
vec_mov_mr(pA0+4,reg6);
vec_mul_mr(pB0+2+KB,reg3);
vec_add_rr(reg2,reg0);
vec_add_rr(reg3,reg1);
vec_mov_rr(reg6,reg2);
vec_mul_mr(pB0+4,reg2);
vec_mov_rr(reg6,reg3);
vec_mov_mr(pA0+6,reg6);
vec_mul_mr(pB0+4+KB,reg3);
vec_add_rr(reg2,reg0);
vec_add_rr(reg3,reg1);
vec_mov_rr(reg6,reg2);
vec_mul_mr(pB0+6,reg2);
vec_mov_rr(reg6,reg3);
vec_mov_mr(pA0+8,reg6);
vec_mul_mr(pB0+6+KB,reg3);
vec_add_rr(reg2,reg0);
vec_add_rr(reg3,reg1);
vec_mov_rr(reg6,reg2);
vec_mul_mr(pB0+8,reg2);
vec_mov_rr(reg6,reg3);
vec_mov_mr(pA0+10,reg6);
vec_mul_mr(pB0+8+KB,reg3);
vec_add_rr(reg2,reg0);
vec_add_rr(reg3,reg1);
vec_mov_rr(reg6,reg2);
vec_mul_mr(pB0+10,reg2);
vec_mov_rr(reg6,reg3);
vec_mov_mr(pA0+12,reg6);
vec_mul_mr(pB0+10+KB,reg3);
vec_add_rr(reg2,reg0);
vec_add_rr(reg3,reg1);
vec_mov_rr(reg6,reg2);
vec_mul_mr(pB0+12,reg2);
vec_mov_rr(reg6,reg3);
vec_mov_mr(pA0+14,reg6);
vec_mul_mr(pB0+12+KB,reg3);
vec_add_rr(reg2,reg0);
vec_add_rr(reg3,reg1);
vec_mov_rr(reg6,reg2);
vec_mul_mr(pB0+14,reg2);
vec_mov_rr(reg6,reg3);
vec_mov_mr(pA0+16,reg6);
vec_mul_mr(pB0+14+KB,reg3);
vec_add_rr(reg2,reg0);
vec_add_rr(reg3,reg1);
pA0 += 16;
pB0 += 16;
}
vec_mov_rr(reg6,reg2);
vec_mul_mr(pB0,reg2);
vec_mov_rr(reg6,reg3);
vec_mov_mr(pA0+2,reg6);
vec_mul_mr(pB0+KB,reg3);
vec_add_rr(reg2,reg0);
vec_add_rr(reg3,reg1);
vec_mov_rr(reg6,reg2);
vec_mul_mr(pB0+2,reg2);
vec_add_rr(reg2,reg0);
vec_mov_rr(reg6,reg3);
vec_mul_mr(pB0+2+KB,reg3);
vec_add_rr(reg3,reg1);
vec_sum(reg0);
vec_sum(reg1);
vec_mov_rm_1(reg0,pC0);
vec_mov_rm_1(reg1,pC1);
pA0 += incAm_m;
pB0 += incBm;
pC0 += (1 SHIFT);
pC1 += (1 SHIFT);
}
while(pA0 != stM_m);
pA0 += incAn_m;
pB0 += incBn;
pC0 += incCn_m;
pC1 += incCn_m;
}
while(pB0 != stN);
}
vec_exit();
}
void bayes_gfl_gaussian_laplace_gamma (int n, double *y, double *w,
int dk_rows, int *dk_rowbreaks, int *dk_cols, double *deltak,
double lambda_hyperparam_a, double lambda_hyperparam_b,
double tau_hyperparameter,
long iterations, long burn, long thin,
double **beta_samples, double *lambda_samples)
{
int i;
double *s;
double *beta;
double *tau;
int **coefs;
int *coef_breaks;
long iteration;
int sample_idx;
double ymean;
const gsl_rng_type *T;
gsl_rng *random;
double lambda;
gsl_rng_env_setup();
T = gsl_rng_default;
random = gsl_rng_alloc (T);
s = (double *) malloc(dk_rows * sizeof(double));
coefs = (int **) malloc(n * sizeof(int*));
coef_breaks = (int *) malloc(n * sizeof(int));
beta = (double *) malloc(n * sizeof(double));
tau = (double *) malloc(dk_rows * sizeof(double));
/* Cache a lookup table to map from deltak column to the set of rows with
non-zero entries for that column */
calc_coefs(n, dk_rows, dk_rowbreaks, dk_cols, coefs, coef_breaks);
/* Set all beta values to the mean to start */
ymean = vec_mean(n, y);
for (i = 0; i < n; i++){ beta[i] = ymean; }
/* Set tau to 1 to start */
for (i = 0; i < dk_rows; i++){ tau[i] = 1.0; }
/* Run the Gibbs sampler */
for (iteration = 0, sample_idx = 0; iteration < iterations; iteration++)
{
/* Sample the lambda penalty weight on the Laplace prior */
lambda = gsl_ran_gamma(random, lambda_hyperparam_a + tau_hyperparameter * dk_rows, 1.0 / (lambda_hyperparam_b + vec_sum(dk_rows, tau)));
/* Sample the local laplace penalty tau */
sample_tau_laplace_gamma(random, beta, dk_rows, dk_rowbreaks, dk_cols, deltak, lambda, tau_hyperparameter, tau);
/* Sample each of the auxillary variables (one per row of Dk) */
sample_prior_aux_laplace_multilambda(random, beta, dk_rows, dk_rowbreaks, dk_cols, deltak, tau, s);
/* Sample from the truncated Gaussian likelihood */
sample_likelihood_gaussian(random, n, y, w, dk_rowbreaks, dk_cols, deltak, s, coefs, coef_breaks, beta);
/* Add the sample */
if (iteration >= burn && (iteration % thin) == 0){
lambda_samples[sample_idx] = lambda;
memcpy(beta_samples[sample_idx], beta, n * sizeof(double));
sample_idx++;
}
}
free(s);
free(tau);
free(beta);
for (i = 0; i < n; i++){ free(coefs[i]); }
free(coefs);
free(coef_breaks);
gsl_rng_free(random);
}
void BSplineSurf::recalcCoords(float ds,float dt)
{
float s,t;
float out[3];
int ns,nt;
myVector<float> sv;
myVector<float> tv;
for (s=U[0]; s<U[1]; s+=ds) {
sv.append(s);
}
sv.append(U[1]);
for (t=V[0]; t<V[1]; t+=dt) {
tv.append(t);
}
tv.append(V[1]);
total_coords=sv.length()*tv.length();
coords=(float(*)[3])malloc(total_coords*sizeof(float[3]));
total_coords=0;
for (ns=0; ns<sv.length(); ns++) {
s=sv.at(ns);
for (nt=0; nt<tv.length(); nt++) {
t=tv.at(nt);
getParamPoint(s,t,coords[total_coords]);
total_coords++;
}
}
myVector<int> N;
int striplen;
for (ns=0; ns<sv.length()-1; ns++) {
N.append(0);
striplen=N.length()-1;
for (nt=0; nt<tv.length(); nt++) {
N.append(nt+tv.length()*ns);
N.append(nt+ tv.length()*(ns+1));
}
N.at(striplen)=tv.length()*2;
}
N.append(0);
free(strip);
strip=(int*)malloc(N.length()*sizeof(int));
memcpy(strip,N.getData(),N.length()*sizeof(int));
free(normals);
normals=(float(*)[3])calloc(total_coords,sizeof(float[3]));
int *ar,totta,k;
ar=strip;
while (ar[0]) {
totta=ar[0]; ar++;
for (k=2; k<totta; k++) {
float g1[3],g2[3],g3[3];
vec_diff(g1,coords[ ar[k-2] ],coords[ ar[k-1] ]);
vec_diff(g2,coords[ ar[k-1] ],coords[ ar[k] ]);
vec_cross_product(g3,g1,g2);
vec_normalize(g3);
if (k&1) {
vec_flip(g3,g3);
}
vec_sum(normals[ ar[k] ],normals[ ar[k] ],g3);
if (k==2) {
vec_sum(normals[ ar[0] ],normals[ ar[0] ],g3);
vec_sum(normals[ ar[1] ],normals[ ar[1] ],g3);
}
}
ar+=totta;
}
for (k=0; k<total_coords; k++) {
vec_normalize(normals[k]);
}
}
void ATL_USERMM
(const int M, const int N, const int K, const double alpha, const double *A, const int lda, const double *B, const int ldb, const double beta, double *C, const int ldc)
{
/*--- program info ---*/
/* $Revision: 1.3 $ */
/* loadfirst = 'b' */
/* nu = 4 */
/* k_loop = 'for' */
/* problem = 'gemm' */
/* nregs = 8 */
/* split = 1 */
/* n_cleanup = {} */
/* mu = 1 */
/* ku = 8 */
/* rev = '$Revision: 1.3 $' */
/* applyfilter = 0 */
/* align_jumps = 0 */
/* prec = 'double' */
/* m_cleanup = {} */
/* used_outside_len = 8 */
/* k_cleanup = {} */
/* outputdir = 'Linux_P4/' */
/* arch = 'sse2' */
/* pipelength = 3 */
/* atlasname = 'Linux_P4' */
/* method = 'acc' */
/* used_lastuse = None */
/* used_directload_a = 0 */
/* outside_len = 'ku' */
/* veclen = 2 */
/* sched = ['spread', 'fuse'] */
/* used_directload_b = 1 */
/* lastuse = 0 */
/*--- achitecture specific declarations ---*/
/*--- program specific declarations ---*/
int i, j, k;
vector betavec;
vector zerovec = {0.0,0.0};
const double *pA0 = A;
const double *pB0 = B;
double *pC0 = C;
double *pC1 = C+(ldc SHIFT);
double *pC2 = C+(2*ldc SHIFT);
double *pC3 = C+(3*ldc SHIFT);
const double *stM = A + MB*KB;
const double *stN = B + NB*KB;
const int incAm = 1*KB-KB+8;
const int incBm = -KB+8;
const int incCm = (1 SHIFT);
const int incAn = -MB*KB;
const int incBn = 4*KB;
const int incCn = ((ldc*4-MB) SHIFT);
/*--- initial arhitecture specific statements ---*/
/*--- main program statements ---*/
vec_mov_mr_1(&beta,reg0);
vec_mov_rm(reg0,betavec);
do /* N-loop */
{
do /* M-loop */
{
#ifdef BETA0
vec_mov_mr(zerovec,reg7);
vec_mov_rr(reg7,reg0);
vec_mov_rr(reg7,reg1);
vec_mov_rr(reg7,reg2);
vec_mov_rr(reg7,reg3);
#elif defined(BETA1)
vec_mov_mr_1(pC0,reg0);
vec_mov_mr_1(pC1,reg1);
vec_mov_mr_1(pC2,reg2);
vec_mov_mr_1(pC3,reg3);
#else
vec_mov_mr(betavec,reg7);
vec_mov_mr_1(pC0,reg0);
vec_mul_rr(reg7,reg0);
vec_mov_mr_1(pC1,reg1);
vec_mul_rr(reg7,reg1);
vec_mov_mr_1(pC2,reg2);
vec_mul_rr(reg7,reg2);
vec_mov_mr_1(pC3,reg3);
vec_mul_rr(reg7,reg3);
#endif
vec_mov_mr_a(pA0,reg7);
vec_mov_mr_a(pB0,reg4);
vec_mul_rr(reg7,reg4);
vec_mov_mr_a(pB0+KB,reg5);
vec_mov_mr_a(pB0+2*KB,reg6);
for (k=0; k<KB-8; k+=8)
{
vec_add_rr(reg4,reg0);
vec_mul_rr(reg7,reg5);
vec_add_rr(reg5,reg1);
vec_mul_rr(reg7,reg6);
vec_add_rr(reg6,reg2);
vec_mov_mr_a(pB0+3*KB,reg4);
vec_mul_rr(reg7,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pA0+2,reg7);
vec_mov_mr_a(pB0+2,reg5);
vec_mul_rr(reg7,reg5);
vec_mov_mr_a(pB0+2+KB,reg6);
vec_mov_mr_a(pB0+2+2*KB,reg4);
vec_add_rr(reg5,reg0);
vec_mul_rr(reg7,reg6);
vec_add_rr(reg6,reg1);
vec_mul_rr(reg7,reg4);
vec_add_rr(reg4,reg2);
vec_mov_mr_a(pB0+2+3*KB,reg5);
vec_mul_rr(reg7,reg5);
vec_add_rr(reg5,reg3);
vec_mov_mr_a(pA0+4,reg7);
vec_mov_mr_a(pB0+4,reg6);
vec_mul_rr(reg7,reg6);
vec_mov_mr_a(pB0+4+KB,reg4);
vec_mov_mr_a(pB0+4+2*KB,reg5);
vec_add_rr(reg6,reg0);
vec_mul_rr(reg7,reg4);
vec_add_rr(reg4,reg1);
vec_mul_rr(reg7,reg5);
vec_add_rr(reg5,reg2);
vec_mov_mr_a(pB0+4+3*KB,reg6);
vec_mul_rr(reg7,reg6);
vec_add_rr(reg6,reg3);
vec_mov_mr_a(pA0+6,reg7);
vec_mov_mr_a(pB0+6,reg4);
vec_mul_rr(reg7,reg4);
vec_mov_mr_a(pB0+6+KB,reg5);
vec_mov_mr_a(pB0+6+2*KB,reg6);
vec_add_rr(reg4,reg0);
vec_mul_rr(reg7,reg5);
vec_add_rr(reg5,reg1);
vec_mul_rr(reg7,reg6);
vec_add_rr(reg6,reg2);
vec_mov_mr_a(pB0+6+3*KB,reg4);
vec_mul_rr(reg7,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pA0+8,reg7);
vec_mov_mr_a(pB0+8,reg4);
vec_mul_rr(reg7,reg4);
vec_mov_mr_a(pB0+8+KB,reg5);
vec_mov_mr_a(pB0+8+2*KB,reg6);
pA0 += 8;
pB0 += 8;
}
vec_add_rr(reg4,reg0);
vec_mul_rr(reg7,reg5);
vec_add_rr(reg5,reg1);
vec_mul_rr(reg7,reg6);
vec_add_rr(reg6,reg2);
vec_mov_mr_a(pB0+3*KB,reg4);
vec_mul_rr(reg7,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pA0+2,reg7);
vec_mov_mr_a(pB0+2,reg5);
vec_mul_rr(reg7,reg5);
vec_mov_mr_a(pB0+2+KB,reg6);
vec_mov_mr_a(pB0+2+2*KB,reg4);
vec_add_rr(reg5,reg0);
vec_mul_rr(reg7,reg6);
vec_add_rr(reg6,reg1);
vec_mul_rr(reg7,reg4);
vec_add_rr(reg4,reg2);
vec_mov_mr_a(pB0+2+3*KB,reg5);
vec_mul_rr(reg7,reg5);
vec_add_rr(reg5,reg3);
vec_mov_mr_a(pA0+4,reg7);
vec_mov_mr_a(pB0+4,reg6);
vec_mul_rr(reg7,reg6);
vec_mov_mr_a(pB0+4+KB,reg4);
vec_mov_mr_a(pB0+4+2*KB,reg5);
vec_add_rr(reg6,reg0);
vec_mul_rr(reg7,reg4);
vec_add_rr(reg4,reg1);
vec_mul_rr(reg7,reg5);
vec_add_rr(reg5,reg2);
vec_mov_mr_a(pB0+4+3*KB,reg4);
vec_mul_rr(reg7,reg4);
vec_add_rr(reg4,reg3);
vec_mov_mr_a(pA0+6,reg7);
vec_mov_mr_a(pB0+6,reg4);
vec_mul_rr(reg7,reg4);
vec_mov_mr_a(pB0+6+KB,reg5);
vec_mov_mr_a(pB0+6+2*KB,reg6);
vec_add_rr(reg4,reg0);
vec_mul_rr(reg7,reg5);
vec_add_rr(reg5,reg1);
vec_mul_rr(reg7,reg6);
vec_add_rr(reg6,reg2);
vec_mov_mr_a(pB0+6+3*KB,reg4);
vec_mul_rr(reg7,reg4);
vec_add_rr(reg4,reg3);
vec_sum(reg0);
vec_sum(reg1);
vec_sum(reg2);
vec_sum(reg3);
vec_mov_rm_1(reg0,pC0);
vec_mov_rm_1(reg1,pC1);
vec_mov_rm_1(reg2,pC2);
vec_mov_rm_1(reg3,pC3);
pA0 += incAm;
pB0 += incBm;
pC0 += incCm;
pC1 += incCm;
pC2 += incCm;
pC3 += incCm;
}
while(pA0 != stM);
pA0 += incAn;
pB0 += incBn;
pC0 += incCn;
pC1 += incCn;
pC2 += incCn;
pC3 += incCn;
}
while(pB0 != stN);
}
Need ompcore(double D[], double x[], double DtX[], double XtX[], double G[], mwSize n, mwSize m, mwSize L,
int T, double eps, int gamma_mode, int profile, double msg_delta, int erroromp)
{
profdata pd;
/* mxArray *Gamma;*/
mwIndex i, j, signum, pos, *ind, *gammaIr, *gammaJc, gamma_count;
mwSize allocated_coefs, allocated_cols;
int DtX_specified, XtX_specified, batchomp, standardomp, *selected_atoms,*times_atoms ;
double *alpha, *r, *Lchol, *c, *Gsub, *Dsub, sum, *gammaPr, *tempvec1, *tempvec2;
double eps2, resnorm, delta, deltaprev, secs_remain;
int mins_remain, hrs_remain;
clock_t lastprint_time, starttime;
Need my;
/*** status flags ***/
DtX_specified = (DtX!=0); /* indicates whether D'*x was provided */
XtX_specified = (XtX!=0); /* indicates whether sum(x.*x) was provided */
standardomp = (G==0); /* batch-omp or standard omp are selected depending on availability of G */
batchomp = !standardomp;
/*** allocate output matrix ***/
if (gamma_mode == FULL_GAMMA) {
/* allocate full matrix of size m X L */
Gamma = mxCreateDoubleMatrix(m, L, mxREAL);
gammaPr = mxGetPr(Gamma);
gammaIr = 0;
gammaJc = 0;
}
else {
/* allocate sparse matrix with room for allocated_coefs nonzeros */
/* for error-omp, begin with L*sqrt(n)/2 allocated nonzeros, otherwise allocate L*T nonzeros */
allocated_coefs = erroromp ? (mwSize)(ceil(L*sqrt((double)n)/2.0) + 1.01) : L*T;
Gamma = mxCreateSparse(m, L, allocated_coefs, mxREAL);
gammaPr = mxGetPr(Gamma);
gammaIr = mxGetIr(Gamma);
gammaJc = mxGetJc(Gamma);
gamma_count = 0;
gammaJc[0] = 0;
}
/*** helper arrays ***/
alpha = (double*)mxMalloc(m*sizeof(double)); /* contains D'*residual */
ind = (mwIndex*)mxMalloc(n*sizeof(mwIndex)); /* indices of selected atoms */
selected_atoms = (int*)mxMalloc(m*sizeof(int)); /* binary array with 1's for selected atoms */
times_atoms = (int*)mxMalloc(m*sizeof(int));
c = (double*)mxMalloc(n*sizeof(double)); /* orthogonal projection result */
/* current number of columns in Dsub / Gsub / Lchol */
allocated_cols = erroromp ? (mwSize)(ceil(sqrt((double)n)/2.0) + 1.01) : T;
/* Cholesky decomposition of D_I'*D_I */
Lchol = (double*)mxMalloc(n*allocated_cols*sizeof(double));
/* temporary vectors for various computations */
tempvec1 = (double*)mxMalloc(m*sizeof(double));
tempvec2 = (double*)mxMalloc(m*sizeof(double));
if (batchomp) {
/* matrix containing G(:,ind) - the columns of G corresponding to the selected atoms, in order of selection */
Gsub = (double*)mxMalloc(m*allocated_cols*sizeof(double));
}
else {
/* matrix containing D(:,ind) - the selected atoms from D, in order of selection */
Dsub = (double*)mxMalloc(n*allocated_cols*sizeof(double));
/* stores the residual */
r = (double*)mxMalloc(n*sizeof(double));
}
if (!DtX_specified) {
/* contains D'*x for the current signal */
DtX = (double*)mxMalloc(m*sizeof(double));
}
/*** initializations for error omp ***/
if (erroromp) {
eps2 = eps*eps; /* compute eps^2 */
if (T<0 || T>n) { /* unspecified max atom num - set max atoms to n */
T = n;
}
}
/*** initialize timers ***/
initprofdata(&pd); /* initialize profiling counters */
starttime = clock(); /* record starting time for eta computations */
lastprint_time = starttime; /* time of last status display */
/********************** perform omp for each signal **********************/
for (signum=0; signum<L; ++signum) {
/* initialize residual norm and deltaprev for error-omp */
if (erroromp) {
if (XtX_specified) {
resnorm = XtX[signum];
}
else {
resnorm = dotprod(x+n*signum, x+n*signum, n);
addproftime(&pd, XtX_TIME);
}
deltaprev = 0; /* delta tracks the value of gamma'*G*gamma */
}
else {
/* ignore residual norm stopping criterion */
eps2 = 0;
resnorm = 1;
}
if (resnorm>eps2 && T>0) {
/* compute DtX */
if (!DtX_specified) {
matT_vec(1, D, x+n*signum, DtX, n, m);
addproftime(&pd, DtX_TIME);
}
/* initialize alpha := DtX */
memcpy(alpha, DtX + m*signum*DtX_specified, m*sizeof(double));
/* mark all atoms as unselected */
for (i=0; i<m; ++i) {
selected_atoms[i] = 0;
}
for (i=0; i<m; ++i) {
times_atoms[i] = 0;
}
}
/* main loop */
i=0;
while (resnorm>eps2 && i<T) {
/* index of next atom */
pos = maxabs(alpha, m);
addproftime(&pd, MAXABS_TIME);
/* stop criterion: selected same atom twice, or inner product too small */
if (selected_atoms[pos] || alpha[pos]*alpha[pos]<1e-14) {
break;
}
/* mark selected atom */
ind[i] = pos;
selected_atoms[pos] = 1;
times_atoms[pos]++;
/* matrix reallocation */
if (erroromp && i>=allocated_cols) {
allocated_cols = (mwSize)(ceil(allocated_cols*MAT_INC_FACTOR) + 1.01);
Lchol = (double*)mxRealloc(Lchol,n*allocated_cols*sizeof(double));
batchomp ? (Gsub = (double*)mxRealloc(Gsub,m*allocated_cols*sizeof(double))) :
(Dsub = (double*)mxRealloc(Dsub,n*allocated_cols*sizeof(double))) ;
}
/* append column to Gsub or Dsub */
if (batchomp) {
memcpy(Gsub+i*m, G+pos*m, m*sizeof(double));
}
else {
memcpy(Dsub+i*n, D+pos*n, n*sizeof(double));
}
/*** Cholesky update ***/
if (i==0) {
*Lchol = 1;
}
else {
/* incremental Cholesky decomposition: compute next row of Lchol */
if (standardomp) {
matT_vec(1, Dsub, D+n*pos, tempvec1, n, i); /* compute tempvec1 := Dsub'*d where d is new atom */
addproftime(&pd, DtD_TIME);
}
else {
vec_assign(tempvec1, Gsub+i*m, ind, i); /* extract tempvec1 := Gsub(ind,i) */
}
backsubst('L', Lchol, tempvec1, tempvec2, n, i); /* compute tempvec2 = Lchol \ tempvec1 */
for (j=0; j<i; ++j) { /* write tempvec2 to end of Lchol */
Lchol[j*n+i] = tempvec2[j];
}
/* compute Lchol(i,i) */
sum = 0;
for (j=0; j<i; ++j) { /* compute sum of squares of last row without Lchol(i,i) */
sum += SQR(Lchol[j*n+i]);
}
if ( (1-sum) <= 1e-14 ) { /* Lchol(i,i) is zero => selected atoms are dependent */
break;
}
Lchol[i*n+i] = sqrt(1-sum);
}
addproftime(&pd, LCHOL_TIME);
i++;
/* perform orthogonal projection and compute sparse coefficients */
vec_assign(tempvec1, DtX + m*signum*DtX_specified, ind, i); /* extract tempvec1 = DtX(ind) */
cholsolve('L', Lchol, tempvec1, c, n, i); /* solve LL'c = tempvec1 for c */
addproftime(&pd, COMPCOEF_TIME);
/* update alpha = D'*residual */
if (standardomp) {
mat_vec(-1, Dsub, c, r, n, i); /* compute r := -Dsub*c */
vec_sum(1, x+n*signum, r, n); /* compute r := x+r */
/*memcpy(r, x+n*signum, n*sizeof(double)); /* assign r := x */
/*mat_vec1(-1, Dsub, c, 1, r, n, i); /* compute r := r-Dsub*c */
addproftime(&pd, COMPRES_TIME);
matT_vec(1, D, r, alpha, n, m); /* compute alpha := D'*r */
addproftime(&pd, DtR_TIME);
/* update residual norm */
if (erroromp) {
resnorm = dotprod(r, r, n);
addproftime(&pd, UPDATE_RESNORM_TIME);
}
}
else {
mat_vec(1, Gsub, c, tempvec1, m, i); /* compute tempvec1 := Gsub*c */
memcpy(alpha, DtX + m*signum*DtX_specified, m*sizeof(double)); /* set alpha = D'*x */
vec_sum(-1, tempvec1, alpha, m); /* compute alpha := alpha - tempvec1 */
addproftime(&pd, UPDATE_DtR_TIME);
/* update residual norm */
if (erroromp) {
vec_assign(tempvec2, tempvec1, ind, i); /* assign tempvec2 := tempvec1(ind) */
delta = dotprod(c,tempvec2,i); /* compute c'*tempvec2 */
resnorm = resnorm - delta + deltaprev; /* residual norm update */
deltaprev = delta;
addproftime(&pd, UPDATE_RESNORM_TIME);
}
}
}
/*** generate output vector gamma ***/
if (gamma_mode == FULL_GAMMA) { /* write the coefs in c to their correct positions in gamma */
for (j=0; j<i; ++j) {
gammaPr[m*signum + ind[j]] = c[j];
}
}
else {
/* sort the coefs by index before writing them to gamma */
quicksort(ind,c,i);
addproftime(&pd, INDEXSORT_TIME);
/* gamma is full - reallocate */
if (gamma_count+i >= allocated_coefs) {
while(gamma_count+i >= allocated_coefs) {
allocated_coefs = (mwSize)(ceil(GAMMA_INC_FACTOR*allocated_coefs) + 1.01);
}
mxSetNzmax(Gamma, allocated_coefs);
mxSetPr(Gamma, mxRealloc(gammaPr, allocated_coefs*sizeof(double)));
mxSetIr(Gamma, mxRealloc(gammaIr, allocated_coefs*sizeof(mwIndex)));
gammaPr = mxGetPr(Gamma);
gammaIr = mxGetIr(Gamma);
}
/* append coefs to gamma and update the indices */
for (j=0; j<i; ++j) {
gammaPr[gamma_count] = c[j];
gammaIr[gamma_count] = ind[j];
gamma_count++;
}
gammaJc[signum+1] = gammaJc[signum] + i;
}
/*** display status messages ***/
if (msg_delta>0 && (clock()-lastprint_time)/(double)CLOCKS_PER_SEC >= msg_delta)
{
lastprint_time = clock();
/* estimated remainig time */
secs2hms( ((L-signum-1)/(double)(signum+1)) * ((lastprint_time-starttime)/(double)CLOCKS_PER_SEC) ,
&hrs_remain, &mins_remain, &secs_remain);
mexPrintf("omp: signal %d / %d, estimated remaining time: %02d:%02d:%05.2f\n",
signum+1, L, hrs_remain, mins_remain, secs_remain);
mexEvalString("drawnow;");
}
}
/* end omp */
/*** print final messages ***/
if (msg_delta>0) {
mexPrintf("omp: signal %d / %d\n", signum, L);
}
if (profile) {
printprofinfo(&pd, erroromp, batchomp, L);
}
/* free memory */
if (!DtX_specified) {
mxFree(DtX);
}
if (standardomp) {
mxFree(r);
mxFree(Dsub);
}
else {
mxFree(Gsub);
}
mxFree(tempvec2);
mxFree(tempvec1);
mxFree(Lchol);
mxFree(c);
mxFree(selected_atoms);
mxFree(ind);
mxFree(alpha);
my.qGamma=Gamma;
my.qtimes__atoms=times__atoms;
/*return Gamma;*/
return my;
}
float vec_sum_square_residuals(avec a, avec b)
{
vec d = vec_sub(a,b);
d = vec_sum(vec_mul(d, d));
return d.x;
}
