/* * finds the first occurrence of a text in a text * * Considering characters that signed char cannot represent and implementations where "plain" char * is signed, casts to unsigned char * are added. */ int (text_find)(text_t s, int i, int j, text_t str) { assert(str.len >= 0 && str.str); /* validity check for texts */ assert(s.len >= 0 && s.str); i = IDX(i, s.len); j = IDX(j, s.len); if (i > j) SWAP(i, j); assert(i >= 0 && j <= s.len); /* validity check for position; see text_pos() */ if (str.len == 0) /* finding empty text always succeeds */ return i + 1; else if (str.len == 1) { /* finding-character case */ for (; i < j; i++) /* note that < is used */ if (((unsigned char *)s.str)[i] == *(unsigned char *)str.str) return i + 1; } else for (; i + str.len <= j; i++) /* note that <= is used and str.len added */ if (EQUAL(s, i, str)) return i + 1; return 0; }
/* * finds the last occurrence of a text in a text * * Considering characters that signed char cannot represent and implementations where "plain" char * is signed, casts to unsigned char * are added. */ int (text_rfind)(text_t s, int i, int j, text_t str) { assert(str.len >= 0 && str.str); /* validity check for text */ assert(s.len >= 0 && s.str); i = IDX(i, s.len); j = IDX(j, s.len); if (i > j) SWAP(i, j); assert(i >= 0 && j <= s.len); /* validity check for position; see text_pos() */ if (str.len == 0) /* finding empty text always succeeds */ return j + 1; else if (str.len == 1) { /* finding-character case */ while (j > i) /* note that > and prefix -- are used */ if (((unsigned char *)s.str)[--j] == *(unsigned char *)str.str) return j + 1; } else for (; j - str.len >= i; j--) /* note that >= is used and str.len subtracted */ if (EQUAL(s, j - str.len, str)) return j - str.len + 1; return 0; }
void // qleftright(const int idim, const hydroparam_t H, hydrovarwork_t * Hvw) qleftright(const int idim, const int Hnx, const int Hny, const int Hnxyt, const int Hnvar, const int slices, const int Hstep, double *qxm, double *qxp, double *qleft, double *qright) { //double qxm[Hnvar][Hstep][Hnxyt], //double qxp[Hnvar][Hstep][Hnxyt], double qleft[Hnvar][Hstep][Hnxyt], double qright[Hnvar][Hstep][Hnxyt]) { // #define IHVW(i,v) ((i) + (v) * Hnxyt) int nvar, i, s; int bmax; WHERE("qleftright"); if (idim == 1) { bmax = Hnx + 1; } else { bmax = Hny + 1; } #pragma acc parallel pcopyin(qxm[0:Hnvar*Hstep*Hnxyt], qxp[0:Hnvar*Hstep*Hnxyt]) pcopyout(qleft[0:Hnvar*Hstep*Hnxyt], qright[0:Hnvar*Hstep*Hnxyt]) #pragma acc loop gang collapse(2) for (nvar = 0; nvar < Hnvar; nvar++) { for (s = 0; s < slices; s++) { #pragma acc loop vector for (i = 0; i < bmax; i++) { qleft[IDX(nvar,s,i)] = qxm[IDX(nvar,s,i + 1)]; qright[IDX(nvar,s,i)] = qxp[IDX(nvar,s,i + 2)]; } } } }
size_t strspn(const char *s, const char *charset) { /* * NB: idx and bit are temporaries whose use causes gcc 3.4.2 to * generate better code. Without them, gcc gets a little confused. */ const char *s1; u_long bit; u_long tbl[(UCHAR_MAX + 1) / LONG_BIT]; int idx; if(*s == '\0') return (0); #if LONG_BIT == 64 /* always better to unroll on 64-bit architectures */ tbl[3] = tbl[2] = tbl[1] = tbl[0] = 0; #else for (idx = 0; idx < sizeof(tbl) / sizeof(tbl[0]); idx++) tbl[idx] = 0; #endif for (; *charset != '\0'; charset++) { idx = IDX(*charset); bit = BIT(*charset); tbl[idx] |= bit; } for(s1 = s; ; s1++) { idx = IDX(*s1); bit = BIT(*s1); if ((tbl[idx] & bit) == 0) break; } return (s1 - s); }
// Chooses representatives at random from x and stores them in r. void pickReps(matrix x, matrix *r){ unint n = x.r; unint i, j; unint *shuf = (unint*)calloc(n, sizeof(*shuf)); for(i=0; i<n; i++) shuf[i]=i; //generate a random permutation of 1..n struct timeval tv; gettimeofday(&tv,NULL); gsl_rng * rng; const gsl_rng_type *rngT; gsl_rng_env_setup(); rngT = gsl_rng_default; rng = gsl_rng_alloc(rngT); gsl_rng_set(rng,tv.tv_usec); gsl_ran_shuffle(rng, shuf, n, sizeof(*shuf)); gsl_rng_free(rng); for(i=0; i<r->r; i++){ for(j=0; j<r->c; j++){ r->mat[IDX( i, j, r->ld )] = x.mat[IDX( shuf[i], j, x.ld )]; } } free(shuf); }
static inline void write_wchars(wchar_t buf[], size_t start, size_t end, bool escape, bool open_field, bool close_field) { size_t j; if (escape) { if (open_field) putwchar(L'"'); for (j = start; j <= end; ++j) { if (buf[IDX(j)] == L'"') putwchar(L'"'); if (putwchar(buf[IDX(j)]) == WEOF) { fprintf(stderr, "putwchar error"); exit(1); } } if (close_field) putwchar(L'"'); } else { for (j = start; j <= end; ++j) { if (putwchar(buf[IDX(j)]) == WEOF) { fprintf(stderr, "putwchar error"); exit(1); } } } }
void WSInfoDelegate::setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& thisindex) const { WeightModel *mymodel = qobject_cast<WeightModel *>(currCombo.model); WSInfoModel *wsim = WSInfoModel::instance(); QModelIndexList matches = wsim->match(wsim->index(0,0), Qt::DisplayRole, currCombo.activeText); int row; if (matches.isEmpty()) { // we need to add this puppy wsim->insertRows(wsim->rowCount(), 1); wsim->setData(wsim->index(wsim->rowCount() - 1, 0), currCombo.activeText); row = wsim->rowCount() - 1; } else { row = matches.first().row(); } int grams = wsim->data(wsim->index(row, WSInfoModel::GR)).toInt(); QVariant v = QString(currCombo.activeText); // don't set if it's the same as it was before setting. if (mymodel->data(thisindex, WeightModel::TYPE).toString() == currCombo.activeText){ return; } mymodel->setData(IDX(WeightModel::TYPE), v, Qt::EditRole); mymodel->passInData(IDX(WeightModel::WEIGHT), grams); qDebug() << "Fixme, every weigth is 0.0 grams. see:" << grams; }
/** * bg_lower_ilevel - lower the index level */ void bg_lower_ilevel(ptst_t *ptst) { unsigned long zero = sl_zero; node_t *node = set->head; node_t *node_next = node; ptst = ptst_critical_enter(); if (node->level-2 <= sl_zero) return; /* no more room to lower */ /* decrement the level of all nodes */ while (node) { node_next = node->succs[IDX(0,zero)]; if (!node->marker) { if (node->level > 0) { if (1 == node->level && node->raise_or_remove) node->raise_or_remove = 0; //BARRIER(); /* null out the ptr for level being removed */ node->succs[IDX(0,zero)] = NULL; --node->level; } } node = node_next; } /* remove the lowest index level */ BARRIER(); /* do all of the above first */ ++sl_zero; ptst_critical_exit(ptst); }
void TankInfoDelegate::setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& thisindex) const { CylindersModel *mymodel = qobject_cast<CylindersModel *>(currCombo.model); TankInfoModel *tanks = TankInfoModel::instance(); QModelIndexList matches = tanks->match(tanks->index(0,0), Qt::DisplayRole, currCombo.activeText); int row; if (matches.isEmpty()) { // we need to add this tanks->insertRows(tanks->rowCount(), 1); tanks->setData(tanks->index(tanks->rowCount() -1, 0), currCombo.activeText); row = tanks->rowCount() - 1; } else { row = matches.first().row(); } int tankSize = tanks->data(tanks->index(row, TankInfoModel::ML)).toInt(); int tankPressure = tanks->data(tanks->index(row, TankInfoModel::BAR)).toInt(); // don't f**k the other data, jimmy. if ( mymodel->data(thisindex, CylindersModel::TYPE).toString() == currCombo.activeText){ return; } mymodel->setData(IDX(CylindersModel::TYPE), currCombo.activeText, Qt::EditRole); mymodel->passInData(IDX(CylindersModel::WORKINGPRESS), tankPressure); mymodel->passInData(IDX(CylindersModel::SIZE), tankSize); }
void equation_of_state(int imin, int imax, const int Hnxyt, const int Hnvar, const double Hsmallc, const double Hgamma, const int slices, const int Hstep, double *eint, double *q, double *c) { //double eint[Hstep][Hnxyt], double q[Hnvar][Hstep][Hnxyt], double c[Hstep][Hnxyt]) { int k, s; double smallp; WHERE("equation_of_state"); smallp = Square(Hsmallc) / Hgamma; CFLOPS(1); #pragma acc parallel pcopyin(eint[0:Hstep*Hnxyt]) pcopy(q[0:Hnvar*Hstep*Hnxyt]) pcopyout(c[0:Hstep*Hnxyt]) #pragma acc loop gang for (s = 0; s < slices; s++) { #pragma acc loop vector for (k = imin; k < imax; k++) { double rhok = q[IDX(ID,s,k)]; double base = (Hgamma - one) * rhok * eint[IDXE(s,k)]; base = MAX(base, (double) (rhok * smallp)); q[IDX(IP,s,k)] = base; c[IDXE(s,k)] = sqrt(Hgamma * base / rhok); CFLOPS(7); } } } // equation_of_state
int main() { freopen("t.in", "r", stdin); freopen("t.out", "w", stdout); int n; scanf("%d", &n); printf("%d", n); for(int i = 0; i < n; i ++) for(int j = 0; j < n; j ++) if(i + j > n) printf(" %d", IDX(i,j)); printf("\n"); printf("%d", nextOdd()); for(int i = 0; i < n; i ++) for(int j = 0; j < n; j ++) if(i + j == n) printf(" %d", IDX(i,j)); printf("\n"); for(int i = n; i >= 2; i --) { printf("%d", nextOdd()); for(int j = 0; j < i; j ++) printf(" %d", IDX(j, i - j - 1)); printf("\n"); } }
/* * checks if a text ends with another text * * Considering characters that signed char cannot represent and implementations where "plain" char * is signed, casts to unsigned char * are added. */ int (text_rmatch)(text_t s, int i, int j, text_t str) { assert(str.len >= 0 && str.str); /* validity check for texts */ assert(s.len >= 0 && s.str); i = IDX(i, s.len); j = IDX(j, s.len); if (i > j) SWAP(i, j); assert(i >= 0 && j <= s.len); /* validity check for position; see text_pos() */ if (str.len == 0) /* finding empty text always succeeds */ return j + 1; else if (str.len == 1) { /* finding-character case */ if (j > i && /* note that > is used */ ((unsigned char *)s.str)[j-1] == *(unsigned char *)str.str) return j; } else if (j - str.len >= i && EQUAL(s, j - str.len, str)) /* note that >= is used and str.len subtracted */ return j - str.len + 1; return 0; }
void WSInfoDelegate::revertModelData(QWidget* widget, QAbstractItemDelegate::EndEditHint hint) { if (hint == QAbstractItemDelegate::NoHint || hint == QAbstractItemDelegate::RevertModelCache){ WeightModel *mymodel = qobject_cast<WeightModel *>(currCombo.model); mymodel->setData(IDX(WeightModel::TYPE), currWeight.type, Qt::EditRole); mymodel->passInData(IDX(WeightModel::WEIGHT), currWeight.weight); } }
static UINT32 i80286_selector_address(i80286_state *cpustate,UINT16 sel) { UINT32 base; UINT16 limit; if(TBL(sel)) { base = cpustate->ldtr.base; limit = cpustate->ldtr.limit; } else { base = cpustate->gdtr.base; limit = cpustate->gdtr.limit; } return ((IDX(sel)>=limit)||!IDXTBL(sel)?-1:base+IDX(sel)); }
static int _op_handler(double *lu, int i, double h2, hpx_addr_t u, hpx_addr_t f) { double left, right, lf; hpx_gas_memget_sync(&left, IDX(u,i-1), sizeof(left)); hpx_gas_memget_sync(&right, IDX(u,i+1), sizeof(right)); hpx_gas_memget_sync(&lf, IDX(f,i), sizeof(lf)); *lu = left + right + h2*lf/2; return HPX_SUCCESS; }
void // qleftright(const int idim, const hydroparam_t H, hydrovarwork_t * Hvw) qleftright (const int idim, const int Hnx, const int Hny, const int Hnxyt, const int Hnvar, const int slices, const int Hstep, hydro_real_t *qxm, hydro_real_t *qxp, hydro_real_t *qleft, hydro_real_t *qright) { //double qxm[Hnvar][Hstep][Hnxyt], //double qxp[Hnvar][Hstep][Hnxyt], double qleft[Hnvar][Hstep][Hnxyt], double qright[Hnvar][Hstep][Hnxyt]) { // #define IHVW(i,v) ((i) + (v) * Hnxyt) //int nvar, i, s; int bmax; WHERE ("qleftright"); if (idim == 1) { bmax = Hnx + 1; } else { bmax = Hny + 1; } #pragma acc kernels present(qxm[0:Hnvar*Hstep*Hnxyt], qxp[0:Hnvar*Hstep*Hnxyt]) present(qleft[0:Hnvar*Hstep*Hnxyt], qright[0:Hnvar*Hstep*Hnxyt]) { #ifdef GRIDIFY #ifndef GRIDIFY_TUNE_PHI #pragma hmppcg gridify(nvar*s,i) #else #pragma hmppcg gridify(nvar*s,i), blocksize 512x1 #endif #endif /* GRIDIFY */ #ifndef GRIDIFY #pragma acc loop independent #endif /* !GRIDIFY */ for (int nvar = 0; nvar < Hnvar; nvar++) { #ifndef GRIDIFY #pragma acc loop independent #endif /* !GRIDIFY */ for (int s = 0; s < slices; s++) { #ifndef GRIDIFY #pragma acc loop independent #endif /* !GRIDIFY */ for (int i = 0; i < bmax; i++) { qleft[IDX (nvar, s, i)] = qxm[IDX (nvar, s, i + 1)]; qright[IDX (nvar, s, i)] = qxp[IDX (nvar, s, i + 2)]; } } } }//kernels region }
int assert_matrix_equality(double *A, double *B, int n){ int i, j; double epsilon = 0.0001; for (i = 0; i < n; i++) for (j = 0; j < n; j++) if (fabs(A[IDX(i, j, n)] - B[IDX(i, j, n)]) > epsilon) return 1; return 0; }
void TankInfoDelegate::revertModelData(QWidget* widget, QAbstractItemDelegate::EndEditHint hint) { if (hint == QAbstractItemDelegate::NoHint || hint == QAbstractItemDelegate::RevertModelCache){ CylindersModel *mymodel = qobject_cast<CylindersModel *>(currCombo.model); mymodel->setData(IDX(CylindersModel::TYPE), currCylinderData.type, Qt::EditRole); mymodel->passInData(IDX(CylindersModel::WORKINGPRESS), currCylinderData.pressure); mymodel->passInData(IDX(CylindersModel::SIZE), currCylinderData.size); } }
const glsl_type * glsl_type::get_instance(unsigned base_type, unsigned rows, unsigned columns) { if (base_type == GLSL_TYPE_VOID) return void_type; if ((rows < 1) || (rows > 4) || (columns < 1) || (columns > 4)) return error_type; /* Treat GLSL vectors as Nx1 matrices. */ if (columns == 1) { switch (base_type) { case GLSL_TYPE_UINT: return uint_type + (rows - 1); case GLSL_TYPE_INT: return int_type + (rows - 1); case GLSL_TYPE_FLOAT: return float_type + (rows - 1); case GLSL_TYPE_BOOL: return bool_type + (rows - 1); default: return error_type; } } else { if ((base_type != GLSL_TYPE_FLOAT) || (rows == 1)) return error_type; /* GLSL matrix types are named mat{COLUMNS}x{ROWS}. Only the following * combinations are valid: * * 1 2 3 4 * 1 * 2 x x x * 3 x x x * 4 x x x */ #define IDX(c,r) (((c-1)*3) + (r-1)) switch (IDX(columns, rows)) { case IDX(2,2): return mat2_type; case IDX(2,3): return mat2x3_type; case IDX(2,4): return mat2x4_type; case IDX(3,2): return mat3x2_type; case IDX(3,3): return mat3_type; case IDX(3,4): return mat3x4_type; case IDX(4,2): return mat4x2_type; case IDX(4,3): return mat4x3_type; case IDX(4,4): return mat4_type; default: return error_type; } } assert(!"Should not get here."); return error_type; }
void copyMat(matrix *x, matrix *y){ unint i,j; x->r=y->r; x->pr=y->pr; x->c=y->c; x->pc=y->pc; x->ld=y->ld; for(i=0; i<y->r; i++){ for(j=0; j<y->c; j++){ x->mat[IDX( i, j, x->ld )] = y->mat[IDX( i, j, y->ld )]; } } }
// C = A^T Mat Mat::T() { // create new Mat for output, and do operation Mat *C = new Mat(ncols,nrows); for (long int j=0; j<ncols; j++) for (long int i=0; i<nrows; i++) C->data[IDX(j,i,ncols)] = data[IDX(i,j,nrows)]; // return result return *C; }
int pdf_jsimp_to_type(pdf_jsimp *imp, pdf_jsimp_obj *obj) { js_State *J = imp->J; if (js_isnull(J, IDX(obj))) return JS_TYPE_NULL; if (js_isboolean(J, IDX(obj))) return JS_TYPE_BOOLEAN; if (js_isnumber(J, IDX(obj))) return JS_TYPE_NUMBER; if (js_isstring(J, IDX(obj))) return JS_TYPE_STRING; if (js_isarray(J, IDX(obj))) return JS_TYPE_ARRAY; return JS_TYPE_UNKNOWN; }
static void transpose(real_t *A, uint_t dim) { for (uint_t i = 0; i < dim; ++i) { for (uint_t j = 0; j < i; ++j) { real_t x = A[IDX(i, j, dim)]; A[IDX(i, j, dim)] = A[IDX(j, i, dim)]; A[IDX(j, i, dim)] = x; } } }
//computes the distance between the kth row of x and the lth row of y float distVec(matrix x, matrix y, unint k, unint l){ unint i, j; float sum=0; for(i=0; i<x.pc; i+=VEC_LEN){ for(j=0; j<VEC_LEN; j++) sum += DIST( x.mat[IDX(k,i+j,x.ld)], y.mat[IDX(l,i+j,x.ld)] ); } return DIST_EXP(sum); }
void set(const int day, const struct interval * interval, const int label) { int i, tmp; if ((interval->stop - interval->start) < 0) return; tmp = interval->start; for (i = interval->start / bin; i < interval->stop / bin; i++) { data[IDX(day, i, label)] += (i + 1) * bin - tmp; tmp = (i + 1) * bin; } data[IDX(day, interval->stop / bin, label)] += interval->stop - tmp; }
static void ComputeQEforRow (const int j, const hydro_real_t Hsmallr, const int Hnx, const int Hnxt, const int Hnyt, const int Hnxyt, const int Hnvar, const int slices, const int Hstep, hydro_real_t *uold, hydro_real_t *q, hydro_real_t *e) { int i, s; // double eken; #define IHV(i, j, v) ((i) + Hnxt * ((j) + Hnyt * (v))) #define IDX(i,j,k) ( (i*Hstep*Hnxyt) + (j*Hnxyt) + k ) #define IDXE(i,j) ( (i*Hnxyt) + j ) #pragma acc kernels present(q[0:Hnvar*Hstep*Hnxyt], uold[0:Hnvar*Hnxt*Hnyt],e[0:Hstep*Hnxyt]) { #ifdef GRIDIFY #ifndef GRIDIFY_TUNE_PHI #pragma hmppcg gridify(s,i) #else #pragma hmppcg gridify(s,i), blocksize 256x2 #endif #endif /* GRIDIFY */ #ifndef GRIDIFY #pragma acc loop independent #endif /* !GRIDIFY */ for (s = 0; s < slices; s++) { #ifndef GRIDIFY #pragma acc loop independent #endif /* !GRIDIFY */ for (i = 0; i < Hnx; i++) { hydro_real_t eken; int idxuID = IHV (i + ExtraLayer, j + s, ID); int idxuIU = IHV (i + ExtraLayer, j + s, IU); int idxuIV = IHV (i + ExtraLayer, j + s, IV); int idxuIP = IHV (i + ExtraLayer, j + s, IP); q[IDX(ID,s,i)] = MAX (uold[idxuID], Hsmallr); q[IDX(IU,s,i)] = uold[idxuIU] / q[IDX(ID,s,i)]; q[IDX(IV,s,i)] = uold[idxuIV] / q[IDX(ID,s,i)]; eken = half * (Square (q[IDX(IU,s,i)]) + Square (q[IDX(IV,s,i)])); q[IDX(IP,s,i)] = uold[idxuIP] / q[IDX(ID,s,i)] - eken; e[IDXE(s,i)] = q[IDX(IP,s,i)]; } } } #undef IHV #undef IHVW }
void pushdown(int l,int r) { int rt=IDX(l,r),mid=l+r>>1; int rtl=IDX(l,mid),rtr=IDX(mid+1,r); if(lzy[rt]) { lzy[rtl]+=lzy[rt]; tree[rtl]+=lzy[rt]*(mid-l+1); lzy[rtr]+=lzy[rt]; tree[rtr]+=lzy[rt]*(r-mid); lzy[rt]=0; } }
void DiamondSquare::smoothHeightField() /* * Smoothes the Vector, by averaging */ { std::vector<float> tempHeightField(inputResolution*inputResolution); for (int x = 0; x < inputResolution; x++) { for (int y = 0; y < inputResolution; y++) { float sum = 0.0f; int count = 0; for (int i = -smoothRange; i <= smoothRange; i++) { int tmp = x + i; if (tmp >= 0 && tmp < inputResolution) { sum += field[IDX(tmp, y, inputResolution)]; count++; } } tempHeightField[IDX(x, y, inputResolution)] = sum / count; } } for (int x = 0; x < inputResolution; x++) { for (int y = 0; y < inputResolution; y++) { float sum = 0.0f; int count = 0; for (int j = -smoothRange; j <= smoothRange; j++) { int tmp = y + j; if (tmp >= 0 && tmp < inputResolution) { sum += tempHeightField[IDX(x, tmp, inputResolution)]; count++; } } field[IDX(x, y, inputResolution)] = sum / count; } } }
void GameScene::updatePlayerInfo() { for(int i=0; i<4; i++) { char szAmount[128]; sprintf(szAmount, "$ %d", player_info[i].getMoney()); pLabelPlayerMoney[i]->setString(szAmount); char szName[128]; if(player_info[i].getPlayerName().length() > 0) { sprintf(szName, "Player%02d", i); pLabelPlayerName[i]->setString(szName); pLabelPlayerName[i]->setColor(ccc3(255, 255, 255)); } else { pLabelPlayerName[i]->setString("WAITING"); pLabelPlayerName[i]->setColor(ccc3(80, 80, 80)); } char szOption[128]; if(player_info[i].getLastOption() == TYPE_CALL) { sprintf(szOption, "CALL (%d$)", player_info[i].getMoney()); } else if(player_info[i].getLastOption() == TYPE_DOUBLE) { sprintf(szOption, "DOUBLE (%d$)", player_info[i].getMoney()); } else if(player_info[i].getLastOption() == TYPE_CHECK) { sprintf(szOption, "CHECK (%d$)", player_info[i].getMoney()); } else if(player_info[i].getLastOption() == TYPE_DIE) { pLabelPlayerName[i]->setString("(DIE)"); pLabelPlayerName[i]->setColor(ccc3(80, 80, 80)); sprintf(szOption, "DIE (0$)"); } else if(player_info[i].getLastOption() == -1) { sprintf(szOption, "waiting...", player_info[i].getMoney()); } pLabelPlayerStatus[i]->setString(szOption); } pLabelPlayerName[IDX(0)]->setString(player_info[IDX(0)].getPlayerName().c_str()); }
int chol(double *A, int n){ unsigned int i; unsigned int j; unsigned int k; for (j = 0; j < n; j++) { for (i = j; i < n; i++) { for (k = 0; k < j; ++k) { A[IDX(i, j, n)] -= A[IDX(i, k, n)] * A[IDX(j, k, n)]; } } if (A[IDX(j, j, n)] < 0.0) { return (1); } A[IDX(j, j, n)] = sqrt(A[IDX(j, j, n)]); for (i = j + 1; i < n; i++) A[IDX(i, j, n)] /= A[IDX(j, j, n)]; } return (0); }