void CompressHistogram(uchar *ch, ulong *h, ulong max, int size)
{
int i;
uchar v;
for(i=0; i<size; i++){
v = ComputeNorm((float) h[i] / (float) max);
ch[i] = (uchar)(v);
}
}
void LinearNormalizeHistogram(uchar *ch, float *h, float max, int size)
{
int i;
uchar v;
for(i=0; i<size; i++){
v = ComputeNorm((float) h[i] / (float) max);
ch[i] = (uchar)(v);
}
}
void BackwardEulerIvpOdeSolver::CalculateNextYValue(AbstractOdeSystem* pAbstractOdeSystem,
double timeStep,
double time,
std::vector<double>& rCurrentYValues,
std::vector<double>& rNextYValues)
{
// Check the size of the ODE system matches the solvers expected
assert(mSizeOfOdeSystem == pAbstractOdeSystem->GetNumberOfStateVariables());
unsigned counter = 0;
// const double eps = 1e-6 * rCurrentGuess[0]; // Our tolerance (should use min(guess) perhaps?)
const double eps = 1e-6; // JonW tolerance
double norm = 2*eps;
std::vector<double> current_guess(mSizeOfOdeSystem);
current_guess.assign(rCurrentYValues.begin(), rCurrentYValues.end());
while (norm > eps)
{
// Calculate Jacobian and mResidual for current guess
ComputeResidual(pAbstractOdeSystem, timeStep, time, rCurrentYValues, current_guess);
ComputeJacobian(pAbstractOdeSystem, timeStep, time, rCurrentYValues, current_guess);
// // Update norm (our style)
// norm = ComputeNorm(mResidual);
// Solve Newton linear system
SolveLinearSystem();
// Update norm (JonW style)
norm = ComputeNorm(mUpdate);
// Update current guess
for (unsigned i=0; i<mSizeOfOdeSystem; i++)
{
current_guess[i] -= mUpdate[i];
}
counter++;
assert(counter < 20); // avoid infinite loops
}
rNextYValues.assign(current_guess.begin(), current_guess.end());
}
AztecOO_StatusType
AztecOO_StatusTestResNorm::CheckStatus(int CurrentIter,
Epetra_MultiVector * CurrentResVector,
double CurrentResNormEst,
bool SolutionUpdated)
{
(void)CurrentIter;
Epetra_Vector * crv = dynamic_cast<Epetra_Vector *>(CurrentResVector);
// This section computes the norm of the residual vector
if (restype_==Implicit && resnormtype_==TwoNorm && CurrentResNormEst!=-1.0)
resvalue_ = CurrentResNormEst;
else if (crv==0) { // Cannot proceed because there is no norm est or res vector
status_ = Failed;
return(status_);
}
else if (restype_==Explicit && SolutionUpdated) {
curresvecexplicit_ = true;
if (localresvector_==0) localresvector_ = new Epetra_Vector(crv->Map());
// Compute explicit residual
operator_.Apply(lhs_, *localresvector_);
localresvector_->Update(1.0, rhs_, -1.0); // localresvector_ = rhs_ - operator_* lhs_
if (resweights_!=0) { // Check if we should scale the vector
// localresvector_ = resweights_ * localresvector_
localresvector_->Multiply(1.0, *resweights_, *localresvector_, 0.0);
}
resvalue_ = ComputeNorm(*localresvector_, resnormtype_);
}
else {
curresvecexplicit_ = false;
if (resweights_!=0) { // Check if we should scale the vector
if (localresvector_==0) localresvector_ = new Epetra_Vector(crv->Map());
// localresvector_ = resweights_ * localresvector_
localresvector_->Multiply(1.0, *resweights_, *crv, 0.0);
resvalue_ = ComputeNorm(*localresvector_, resnormtype_);
}
else
resvalue_ = ComputeNorm(*crv, resnormtype_);
}
// Compute scaling term (done once)
if (firstcallCheckStatus_) {
if (scaletype_==NormOfRHS) {
if (scaleweights_!=0) { // Check if we should scale the vector
if (localresvector_==0) localresvector_ = new Epetra_Vector(rhs_.Map());
// localresvector = scaleweights_ * rhs_
localresvector_->Multiply(1.0, *scaleweights_, rhs_, 0.0);
scalevalue_ = ComputeNorm(*localresvector_, resnormtype_);
}
else {
scalevalue_ = ComputeNorm(rhs_, scalenormtype_);
}
}
else if (scaletype_==NormOfInitRes) {
if (restype_==Implicit && scalenormtype_==TwoNorm && CurrentResNormEst!=-1.0)
scalevalue_ = CurrentResNormEst;
else {
if (scaleweights_!=0) { // Check if we should scale the vector
if (localresvector_==0) localresvector_ = new Epetra_Vector(crv->Map());
// weightedrhs = scaleweights_ * initial residual
localresvector_->Multiply(1.0, *scaleweights_, *crv, 0.0);
scalevalue_ = ComputeNorm(*localresvector_, resnormtype_);
}
else {
scalevalue_ = ComputeNorm(rhs_, scalenormtype_);
}
}
}
if (scalevalue_==0.0) {
status_ = Failed;
return(status_);
}
}
testvalue_ = resvalue_/scalevalue_;
if (testvalue_>tolerance_)
if (convergedOnce_) {
if (numExtraIterations_<maxNumExtraIterations_) {
numExtraIterations_++;
status_ = Unconverged;
}
else {
status_ = PartialFailed;
}
}
else {
status_ = Unconverged;
}
else if (testvalue_<=tolerance_) {
convergedOnce_ = true;
status_ = Converged;
}
else
status_ = NaN;
firstcallCheckStatus_ = false;
return status_;
}
