float Animator::_calculateValue(float k) { if (this->delay > 0.0f) { return (this->discreteStep != 0 ? (float)((int)(this->offset / this->discreteStep) * this->discreteStep) : this->offset); } float time = this->timer; if (this->isExpired()) { if (this->reset) { return (this->discreteStep != 0 ? (float)((int)(this->offset / this->discreteStep) * this->discreteStep) : this->offset); } time = this->periods / habs(this->speed); } float result = 0.0f; switch (this->animationFunction) { case Object::Linear: result = time * this->speed * this->amplitude; break; case Object::Sine: result = (float)dsin(time * this->speed * 360) * this->amplitude; break; case Object::Square: result = (hmodf(time * this->speed, 1.0f) < 0.5f ? this->amplitude : -this->amplitude); break; case Object::Saw: result = (hmodf(time * this->speed + 0.5f, 1.0f) - 0.5f) * 2 * this->amplitude; break; case Object::Triangle: result = hmodf(time * this->speed, 1.0f); if (!is_in_range(result, 0.25f, 0.75f)) { result = (hmodf(time * this->speed + 0.5f, 1.0f) - 0.5f) * 4 * this->amplitude; } else { result = -(hmodf(time * this->speed - 0.25f, 1.0f) - 0.25f) * 4 * this->amplitude; } break; case Object::Random: result = hrandf(-this->speed * this->amplitude, this->speed * this->amplitude); break; case Object::Hover: if ((this->amplitude >= 0.0f) == this->parent->isCursorInside()) { result = hmin(this->value - this->offset + k * this->speed, (float)habs(this->amplitude)); } else { result = hmax(this->value - this->offset - k * this->speed, -(float)habs(this->amplitude)); } break; case Object::Custom: result = (this->customFunction != NULL ? this->customFunction(this, time) : this->value); break; } return (this->discreteStep != 0 ? (float)((int)((result + this->offset) / this->discreteStep) * this->discreteStep) : (result + this->offset)); }
int HYPRE_LSI_ILUTDecompose( HYPRE_LSI_Schwarz *sch_ptr ) { int i, j, k, blk, nrows, rleng, *cols, *track_array, track_leng; int nblocks, max_blk_size, *mat_ia, *mat_ja, *new_ia, *new_ja; int index, first, sortcnt, *sortcols, Lcount, Ucount, nnz, new_nnz; int colIndex, mypid, output_level, printflag, printflag2; double fillin, *vals, *dble_buf, *rowNorms, *diagonal, *mat_aa, *new_aa; double *sortvals, ddata, tau, rel_tau, absval; /* --------------------------------------------------------- */ /* preparation phase */ /* --------------------------------------------------------- */ MPI_Comm_rank(sch_ptr->comm, &mypid); output_level = sch_ptr->output_level; nblocks = sch_ptr->nblocks; max_blk_size = 0; for ( blk = 0; blk < nblocks; blk++ ) if ( sch_ptr->blk_sizes[blk] > max_blk_size ) max_blk_size = sch_ptr->blk_sizes[blk]; fillin = sch_ptr->fillin; tau = sch_ptr->threshold; track_array = (int *) malloc( max_blk_size * sizeof(int) ); sortcols = (int *) malloc( max_blk_size * sizeof(int) ); sortvals = (double *) malloc( max_blk_size * sizeof(double) ); dble_buf = (double *) malloc( max_blk_size * sizeof(double) ); diagonal = (double *) malloc( max_blk_size * sizeof(double) ); rowNorms = (double *) malloc( max_blk_size * sizeof(double) ); for ( i = 0; i < max_blk_size; i++ ) dble_buf[i] = 0.0; /* --------------------------------------------------------- */ /* process the rows */ /* --------------------------------------------------------- */ printflag = nblocks / 10 + 1; for ( blk = 0; blk < nblocks; blk++ ) { if ( output_level > 0 && blk % printflag == 0 && blk != 0 ) printf("%4d : Schwarz : processing block %6d (%6d)\n",mypid,blk,nblocks); mat_ia = sch_ptr->bmat_ia[blk]; mat_ja = sch_ptr->bmat_ja[blk]; mat_aa = sch_ptr->bmat_aa[blk]; nrows = sch_ptr->blk_sizes[blk]; nnz = mat_ia[nrows]; new_nnz = (int) (nnz * ( 1.0 + fillin )); new_ia = (int *) malloc( (nrows + 1 ) * sizeof(int) ); new_ja = (int *) malloc( new_nnz * sizeof(int) ); new_aa = (double *) malloc( new_nnz * sizeof(double) ); nnz = 0; new_ia[0] = nnz; for ( i = 0; i < nrows; i++ ) { index = mat_ia[i]; cols = &(mat_ja[index]); vals = &(mat_aa[index]); rleng = mat_ia[i+1] - index; ddata = 0.0; for ( j = 0; j < rleng; j++ ) ddata += habs( vals[j] ); rowNorms[i] = ddata; } printflag2 = nrows / 10 + 1; for ( i = 0; i < nrows; i++ ) { if ( output_level > 0 && i % printflag2 == 0 && i != 0 ) printf("%4d : Schwarz : block %6d row %6d (%6d)\n",mypid,blk, i, nrows); track_leng = 0; index = mat_ia[i]; cols = &(mat_ja[index]); vals = &(mat_aa[index]); rleng = mat_ia[i+1] - index; for ( j = 0; j < rleng; j++ ) { dble_buf[cols[j]] = vals[j]; track_array[track_leng++] = cols[j]; } Lcount = Ucount = first = 0; first = nrows; for ( j = 0; j < track_leng; j++ ) { index = track_array[j]; if ( dble_buf[index] != 0 ) { if ( index < i ) Lcount++; else if ( index > i ) Ucount++; else if ( index == i ) diagonal[i] = dble_buf[index]; if ( index < first ) first = index; } } Lcount = Lcount * fillin; Ucount = Ucount * fillin; rel_tau = tau * rowNorms[i]; for ( j = first; j < i; j++ ) { if ( habs(dble_buf[j]) > rel_tau ) { ddata = dble_buf[j] / diagonal[j]; for ( k = new_ia[j]; k < new_ia[j+1]; k++ ) { colIndex = new_ja[k]; if ( colIndex > j ) { if ( dble_buf[colIndex] != 0.0 ) dble_buf[colIndex] -= (ddata * new_aa[k]); else { dble_buf[colIndex] = - (ddata * new_aa[k]); if ( dble_buf[colIndex] != 0.0 ) track_array[track_leng++] = colIndex; } } } dble_buf[j] = ddata; } else dble_buf[j] = 0.0; } for ( j = 0; j < rleng; j++ ) { vals[j] = dble_buf[cols[j]]; if ( cols[j] != i ) dble_buf[cols[j]] = 0.0; } sortcnt = 0; for ( j = 0; j < track_leng; j++ ) { index = track_array[j]; if ( index < i ) { absval = habs( dble_buf[index] ); if ( absval > rel_tau ) { sortcols[sortcnt] = index; sortvals[sortcnt++] = absval * rowNorms[index]; } else dble_buf[index] = 0.0; } } if ( sortcnt > Lcount ) { HYPRE_LSI_SplitDSort(sortvals,sortcnt,sortcols,Lcount); for ( j = Lcount; j < sortcnt; j++ ) dble_buf[sortcols[j]] = 0.0; } for ( j = 0; j < rleng; j++ ) { if ( cols[j] < i && vals[j] != 0.0 ) { new_aa[nnz] = vals[j]; new_ja[nnz++] = cols[j]; } } for ( j = 0; j < track_leng; j++ ) { index = track_array[j]; if ( index < i && dble_buf[index] != 0.0 ) { new_aa[nnz] = dble_buf[index]; new_ja[nnz++] = index; dble_buf[index] = 0.0; } } diagonal[i] = dble_buf[i]; if ( habs(diagonal[i]) < 1.0e-12 ) diagonal[i] = 1.0E-12; new_aa[nnz] = diagonal[i]; new_ja[nnz++] = i; sortcnt = 0; for ( j = 0; j < track_leng; j++ ) { index = track_array[j]; if ( index > i ) { absval = habs( dble_buf[index] ); if ( absval > rel_tau ) { sortcols[sortcnt] = index; sortvals[sortcnt++] = absval * rowNorms[index]; } else dble_buf[index] = 0.0; } } if ( sortcnt > Ucount ) { HYPRE_LSI_SplitDSort(sortvals,sortcnt,sortcols,Ucount); for ( j = Ucount; j < sortcnt; j++ ) dble_buf[sortcols[j]] = 0.0; } for ( j = 0; j < rleng; j++ ) { if ( cols[j] > i && vals[j] != 0.0 ) { new_aa[nnz] = vals[j]; new_ja[nnz++] = cols[j]; } } for ( j = 0; j < track_leng; j++ ) { index = track_array[j]; if ( index > i && dble_buf[index] != 0.0 ) { new_aa[nnz] = dble_buf[index]; new_ja[nnz++] = index; dble_buf[index] = 0.0; } } dble_buf[i] = 0.0; new_ia[i+1] = nnz; } free( mat_ia ); free( mat_ja ); free( mat_aa ); sch_ptr->bmat_ia[blk] = new_ia; sch_ptr->bmat_ja[blk] = new_ja; sch_ptr->bmat_aa[blk] = new_aa; if ( nnz > new_nnz ) { printf("ERROR : nnz (%d) > new_nnz (%d) \n", nnz, new_nnz); exit(1); } for ( j = 0; j < new_ia[sch_ptr->blk_sizes[blk]]; j++ ) { if ( new_ja[j] < 0 || new_ja[j] >= sch_ptr->blk_sizes[blk] ) { printf("(2) block %d has index %d\n", blk, new_ja[j]); exit(1); } } } free( track_array ); free( dble_buf ); free( diagonal ); free( rowNorms ); free( sortcols ); free( sortvals ); return 0; }
void ScrollBar::addScrollValueEnd(float multiplier) { this->addScrollValue(hmax(habs(this->gridSize), (float)(int)(habs(ScrollBar::ScrollDistance) * multiplier))); }
bool Animator::isExpired() { return (!this->enabled || this->periods >= 0.0f && this->timer * habs(this->speed) > this->periods); }
int HYPRE_LSI_MatrixInverse( double **Amat, int ndim, double ***Cmat ) { int i, j, k; double denom, **Bmat, dmax; (*Cmat) = NULL; if ( ndim == 1 ) { if ( habs(Amat[0][0]) <= 1.0e-16 ) return -1; Bmat = (double **) malloc( ndim * sizeof(double*) ); for ( i = 0; i < ndim; i++ ) Bmat[i] = (double *) malloc( ndim * sizeof(double) ); Bmat[0][0] = 1.0 / Amat[0][0]; (*Cmat) = Bmat; return 0; } if ( ndim == 2 ) { denom = Amat[0][0] * Amat[1][1] - Amat[0][1] * Amat[1][0]; if ( habs( denom ) <= 1.0e-16 ) return -1; Bmat = (double **) malloc( ndim * sizeof(double*) ); for ( i = 0; i < ndim; i++ ) Bmat[i] = (double *) malloc( ndim * sizeof(double) ); Bmat[0][0] = Amat[1][1] / denom; Bmat[1][1] = Amat[0][0] / denom; Bmat[0][1] = - ( Amat[0][1] / denom ); Bmat[1][0] = - ( Amat[1][0] / denom ); (*Cmat) = Bmat; return 0; } else { Bmat = (double **) malloc( ndim * sizeof(double*) ); for ( i = 0; i < ndim; i++ ) { Bmat[i] = (double *) malloc( ndim * sizeof(double) ); for ( j = 0; j < ndim; j++ ) Bmat[i][j] = 0.0; Bmat[i][i] = 1.0; } for ( i = 1; i < ndim; i++ ) { for ( j = 0; j < i; j++ ) { if ( habs(Amat[j][j]) < 1.0e-16 ) return -1; denom = Amat[i][j] / Amat[j][j]; for ( k = 0; k < ndim; k++ ) { Amat[i][k] -= denom * Amat[j][k]; Bmat[i][k] -= denom * Bmat[j][k]; } } } for ( i = ndim-2; i >= 0; i-- ) { for ( j = ndim-1; j >= i+1; j-- ) { if ( habs(Amat[j][j]) < 1.0e-16 ) return -1; denom = Amat[i][j] / Amat[j][j]; for ( k = 0; k < ndim; k++ ) { Amat[i][k] -= denom * Amat[j][k]; Bmat[i][k] -= denom * Bmat[j][k]; } } } for ( i = 0; i < ndim; i++ ) { denom = Amat[i][i]; if ( habs(denom) < 1.0e-16 ) return -1; for ( j = 0; j < ndim; j++ ) Bmat[i][j] /= denom; } for ( i = 0; i < ndim; i++ ) for ( j = 0; j < ndim; j++ ) if ( habs(Bmat[i][j]) < 1.0e-17 ) Bmat[i][j] = 0.0; dmax = 0.0; for ( i = 0; i < ndim; i++ ) { for ( j = 0; j < ndim; j++ ) if ( habs(Bmat[i][j]) > dmax ) dmax = habs(Bmat[i][j]); /* for ( j = 0; j < ndim; j++ ) if ( habs(Bmat[i][j]/dmax) < 1.0e-15 ) Bmat[i][j] = 0.0; */ } (*Cmat) = Bmat; if ( dmax > 1.0e6 ) return 1; else return 0; } }
int HYPRE_LSI_PolySetup(HYPRE_Solver solver, HYPRE_ParCSRMatrix A_csr, HYPRE_ParVector b, HYPRE_ParVector x ) { int i, j, my_id, startRow, endRow, order; int pos_diag, neg_diag; int rowLeng, *colInd, *row_partition; double *coefs=NULL, rowsum, max_norm, *colVal; HYPRE_LSI_Poly *poly_ptr = (HYPRE_LSI_Poly *) solver; #ifndef HYPRE_SEQUENTIAL double dtemp; #endif /* ---------------------------------------------------------------- */ /* initialize structure */ /* ---------------------------------------------------------------- */ order = poly_ptr->order; coefs = (double *) malloc((order+1) * sizeof(double)); poly_ptr->coefficients = coefs; /* ---------------------------------------------------------------- */ /* compute matrix norm */ /* ---------------------------------------------------------------- */ HYPRE_ParCSRMatrixGetRowPartitioning( A_csr, &row_partition ); #ifdef HYPRE_SEQUENTIAL my_id = 0; #else MPI_Comm_rank(poly_ptr->comm, &my_id); #endif startRow = row_partition[my_id]; endRow = row_partition[my_id+1] - 1; hypre_TFree( row_partition ); poly_ptr->Nrows = endRow - startRow + 1; max_norm = 0.0; pos_diag = neg_diag = 0; for ( i = startRow; i <= endRow; i++ ) { HYPRE_ParCSRMatrixGetRow(A_csr, i, &rowLeng, &colInd, &colVal); rowsum = 0.0; for (j = 0; j < rowLeng; j++) { rowsum += habs(colVal[j]); if ( colInd[j] == i && colVal[j] > 0.0 ) pos_diag++; if ( colInd[j] == i && colVal[j] < 0.0 ) neg_diag++; } if ( rowsum > max_norm ) max_norm = rowsum; HYPRE_ParCSRMatrixRestoreRow(A_csr, i, &rowLeng, &colInd, &colVal); } #ifndef HYPRE_SEQUENTIAL MPI_Allreduce(&max_norm, &dtemp, 1, MPI_INT, MPI_MAX, poly_ptr->comm); #endif if ( pos_diag == 0 && neg_diag > 0 ) max_norm = - max_norm; /* ---------------------------------------------------------------- */ /* fill in the coefficient table */ /* ---------------------------------------------------------------- */ switch ( order ) { case 0: coefs[0] = 1.0; break; case 1: coefs[0] = 5.0; coefs[1] = -1.0; break; case 2: coefs[0] = 14.0; coefs[1] = -7.0; coefs[2] = 1.0; break; case 3: coefs[0] = 30.0; coefs[1] = -27.0; coefs[2] = 9.0; coefs[3] = -1.0; break; case 4: coefs[0] = 55.0; coefs[1] = -77.0; coefs[2] = 44.0; coefs[3] = -11.0; coefs[4] = 1.0; break; case 5: coefs[0] = 91.0; coefs[1] = -182.0; coefs[2] = 156.0; coefs[3] = -65.0; coefs[4] = 13.0; coefs[5] = -1.0; break; case 6: coefs[0] = 140.0; coefs[1] = -378.0; coefs[2] = 450.0; coefs[3] = -275.0; coefs[4] = 90.0; coefs[5] = -15.0; coefs[6] = 1.0; break; case 7: coefs[0] = 204.0; coefs[1] = -714.0; coefs[2] = 1122.0; coefs[3] = -935.0; coefs[4] = 442.0; coefs[5] = -119.0; coefs[6] = 17.0; coefs[7] = -1.0; break; case 8: coefs[0] = 285.0; coefs[1] = -1254.0; coefs[2] = 2508.0; coefs[3] = -2717.0; coefs[4] = 1729.0; coefs[5] = -665.0; coefs[6] = 152.0; coefs[7] = -19.0; coefs[8] = 1.0; break; } for( i = 0; i <= order; i++ ) coefs[i] *= pow( 4.0 / max_norm, (double) i); return 0; }