@@ -39,6 +39,7 @@ void GibbsSampler::setMatrix(const Matrix &mat)

 {   

     GAPS_ASSERT(mat.nRow() == mMatrix.nRow());

     GAPS_ASSERT(mat.nCol() == mMatrix.nCol());

+

     mMatrix = mat;

 }

@@ -60,34 +61,25 @@ void GibbsSampler::sync(const GibbsSampler &sampler)

 void GibbsSampler::update(unsigned nSteps, unsigned nCores)

 {

-    unsigned n = 0;

-    while (n < nSteps)

+    for (unsigned n = 0; n < nSteps; ++n)

     {

         makeAndProcessProposal();

-        ++n;

     }

 }

 void GibbsSampler::makeAndProcessProposal()

 {

-    // always birth when no atoms exist

-    if (mDomain.size() == 0)

+    if (mDomain.size() < 2)

     {

         return birth();

     }

-    float bdProb = mDomain.size() < 2 ? 0.6667f : 0.5f;

-

     float u1 = mPropRng.uniform();

-    float u2 = mPropRng.uniform();

-

-    float lowerBound = deathProb(mDomain.size());

-

-    if (u1 <= bdProb)

+    if (u1 < 0.5f)

     {

-        return u2 < lowerBound ? death() : birth();

+        return mPropRng.uniform() < deathProb(mDomain.size()) ? death() : birth();

     }

-    return (u1 < 0.75f || mDomain.size() < 2) ? move() : exchange();

+    return (u1 < 0.75f) ? move() : exchange();

 }

 float GibbsSampler::deathProb(uint64_t nAtoms) const

@@ -109,7 +101,7 @@ void GibbsSampler::birth()

     // calculate proposed mass

     float mass = canUseGibbs(col)

-        ? gibbsMass(alphaParameters(row, col), &rng).value

+        ? gibbsMass(alphaParameters(row, col), &rng).value()

         : rng.exponential(mLambda);

     // accept mass as long as it's non-zero

@@ -122,7 +114,7 @@ void GibbsSampler::birth()

 }

 // automatically accept death, attempt a rebirth at the same position, using

-// the original mass or the gibbs mass calculation

+// the original mass or the gibbs mass distribution

 void GibbsSampler::death()

 {

     // get random atom

@@ -131,30 +123,32 @@ void GibbsSampler::death()

     unsigned col = getCol(atom->pos);

     GapsRng rng;

-    // kill off atom

-    safelyChangeMatrix(row, col, -1.f * atom->mass);

-

-    // calculate rebirth mass

-    AlphaParameters alpha = alphaParameters(row, col);

+    // calculate alpha parameters assuming atom dies

+    AlphaParameters alpha = alphaParametersWithChange(row, col, -atom->mass);

     float rebirthMass = atom->mass;

+    bool useSame = true;

     if (canUseGibbs(col))

     {

         OptionalFloat gMass = gibbsMass(alpha, &rng);

-        if (gMass.hasValue)

+        if (gMass.hasValue())

         {

-            rebirthMass = gMass.value;

+            rebirthMass = gMass.value();

+            useSame = false;

         }

     }

     // accept/reject rebirth

-    if (getDeltaLL(alpha, rebirthMass) * mAnnealingTemp >= std::log(rng.uniform()))

+    if (std::log(rng.uniform()) < getDeltaLL(alpha, rebirthMass) * mAnnealingTemp)

     {

-        atom->mass = rebirthMass;

-        mMatrix(row, col) += rebirthMass;

-        updateAPMatrix(row, col, rebirthMass);

+        if (!useSame)

+        {

+            safelyChangeMatrix(row, col, rebirthMass - atom->mass);

+            atom->mass = rebirthMass;

+        }

     }

     else

     {

+        safelyChangeMatrix(row, col, -atom->mass);

         mDomain.erase(atom->pos);

     }

 }

@@ -176,11 +170,10 @@ void GibbsSampler::move()

     {

         GapsRng rng;

         AlphaParameters alpha = alphaParameters(r1, c1, r2, c2);

-        float deltaLL = getDeltaLL(alpha, -1.f * hood.center->mass);

-        if (deltaLL * mAnnealingTemp > std::log(rng.uniform()))

+        if (std::log(rng.uniform()) < getDeltaLL(alpha, -hood.center->mass) * mAnnealingTemp)

         {

             hood.center->pos = newLocation;

-            safelyChangeMatrix(r1, c1, -1.f * hood.center->mass);

+            safelyChangeMatrix(r1, c1, -hood.center->mass);

             mMatrix(r2, c2) += hood.center->mass;

             updateAPMatrix(r2, c2, hood.center->mass);

         }

@@ -208,28 +201,27 @@ void GibbsSampler::exchange()

     if (r1 != r2 || c1 != c2)

     {

         GapsRng rng;

-

-        float m1 = a1->mass;

-        float m2 = a2->mass;

-

         AlphaParameters alpha = alphaParameters(r1, c1, r2, c2);

         if (canUseGibbs(c1, c2))

         {

-            OptionalFloat gMass = gibbsMass(alpha, m1, m2, &rng);

-            if (gMass.hasValue)

+            OptionalFloat gMass = gibbsMass(alpha, a1->mass, a2->mass, &rng);

+            if (gMass.hasValue())

             {

-                acceptExchange(a1, a2, gMass.value, r1, c1, r2, c2);

+                acceptExchange(a1, a2, gMass.value(), r1, c1, r2, c2);

                 return;

             }

         }

-        float newMass = rng.truncGammaUpper(m1 + m2, 2.f, 1.f / mLambda);

+        float newMass = rng.truncGammaUpper(a1->mass + a2->mass, 2.f, 1.f / mLambda);

-        float delta = m1 > m2 ? newMass - m1 : m2 - newMass; // change larger mass

-        float pOldMass = 2.f * newMass > m1 + m2 ? gaps::max(m1, m2) : gaps::min(m1, m2);

+        // change larger mass

+        float delta = a1->mass > a2->mass ? newMass - a1->mass : a2->mass - newMass;

+        float oldMass = (2.f * newMass > a1->mass + a2->mass)

+            ? gaps::max(a1->mass, a2->mass)

+            : gaps::min(a1->mass, a2->mass);

         float pNew = gaps::d_gamma(newMass, 2.f, 1.f / mLambda);

-        float pOld = gaps::d_gamma(pOldMass, 2.f, 1.f / mLambda);

+        float pOld = gaps::d_gamma(oldMass, 2.f, 1.f / mLambda);

         float deltaLL = getDeltaLL(alpha, delta);

         float priorLL = (pNew == 0.f) ? 1.f : pOld / pNew;

@@ -383,6 +375,14 @@ unsigned r2, unsigned c2)

     return alphaParameters(r1, c1) + alphaParameters(r2, c2);

 }

+AlphaParameters GibbsSampler::alphaParametersWithChange(unsigned row,

+unsigned col, float ch)

+{

+    return gaps::algo::alphaParametersWithChange(mDMatrix.nRow(),

+        mDMatrix.colPtr(row), mSMatrix.colPtr(row), mAPMatrix.colPtr(row),

+        mOtherMatrix->colPtr(col), ch);

+}

+

 Archive& operator<<(Archive &ar, GibbsSampler &s)

 {

     // TODO

@@ -2,7 +2,6 @@

 #define __COGAPS_GIBBS_SAMPLER_H__

 #include "AtomicDomain.h"

-#include "ProposalQueue.h"

 #include "data_structures/Matrix.h"

 #include "math/Algorithms.h"

 #include "math/Random.h"

@@ -92,8 +91,8 @@ private:

     bool canUseGibbs(unsigned c1, unsigned c2) const;

     AlphaParameters alphaParameters(unsigned row, unsigned col);

-    AlphaParameters alphaParameters(unsigned r1, unsigned c1, unsigned r2,

-        unsigned c2);

+    AlphaParameters alphaParameters(unsigned r1, unsigned c1, unsigned r2, unsigned c2);

+    AlphaParameters alphaParametersWithChange(unsigned row, unsigned col, float ch);

 };

 template <class DataType>

@@ -8,7 +8,6 @@ OBJECTS =   AtomicDomain.o \

             GapsRunner.o \

             GapsStatistics.o \

             GibbsSampler.o \

-            ProposalQueue.o \

             RcppExports.o \

             test-runner.o \

             data_structures/Matrix.o \

deleted file mode 100644

@@ -1,277 +0,0 @@

-#include "utils/GapsAssert.h"

-#include "ProposalQueue.h"

-#include "math/Random.h"

-

-//////////////////////////////// AtomicProposal ////////////////////////////////

-

-// birth

-AtomicProposal::AtomicProposal(char t, uint64_t pos)

-    : type(t), birthPos(pos), moveDest(0), atom1(NULL), atom2(NULL)

-{}

-    

-// death

-AtomicProposal::AtomicProposal(char t, Atom *atom)

-    : type(t), birthPos(0), moveDest(0), atom1(atom), atom2(NULL)

-{}

-

-// move

-AtomicProposal::AtomicProposal(char t, Atom *atom, uint64_t dest)

-    : type(t), birthPos(0), moveDest(dest), atom1(atom), atom2(NULL)

-{}

-

-// exchange

-AtomicProposal::AtomicProposal(char t, Atom *a1, Atom *a2)

-    : type(t), birthPos(0), moveDest(0), atom1(a1), atom2(a2)

-{}

-

-

-//////////////////////////////// ProposalQueue /////////////////////////////////

-

-ProposalQueue::ProposalQueue(unsigned primaryDimSize, unsigned secondaryDimSize)

-    :

-mMinAtoms(0), mMaxAtoms(0), mNumBins(primaryDimSize * secondaryDimSize),

-mBinLength(std::numeric_limits<uint64_t>::max() / mNumBins),

-mSecondaryDimLength(mBinLength * secondaryDimSize),

-mDomainLength(mBinLength * mNumBins), mSecondaryDimSize(secondaryDimSize),

-mAlpha(0.f), mU1(0.f), mU2(0.f), mUseCachedRng(false)

-{

-    mUsedIndices.setDimensionSize(primaryDimSize);

-}

-

-void ProposalQueue::setAlpha(float alpha)

-{

-    mAlpha = alpha;

-}

-

-void ProposalQueue::populate(AtomicDomain &domain, unsigned limit)

-{

-    GAPS_ASSERT(mMinAtoms == mMaxAtoms);

-    GAPS_ASSERT(mMaxAtoms == domain.size());

-

-    unsigned nIter = 0;

-    bool success = true;

-    while (nIter++ < limit && success)

-    {

-        success = makeProposal(domain);

-        if (!success)

-        {

-            mUseCachedRng = true;

-        }

-    }

-}

-

-void ProposalQueue::clear()

-{

-    GAPS_ASSERT(mMinAtoms == mMaxAtoms);

-

-    mQueue.clear();

-    mUsedPositions.clear();

-    mUsedIndices.clear();

-}

-

-unsigned ProposalQueue::size() const

-{

-    return mQueue.size();

-}

-

-AtomicProposal& ProposalQueue::operator[](int n)

-{

-    GAPS_ASSERT(mQueue.size() > 0);

-    GAPS_ASSERT(n < mQueue.size());

-

-    return mQueue[n];

-}

-

-void ProposalQueue::acceptDeath()

-{

-    #pragma omp atomic

-    mMaxAtoms--;

-}

-

-void ProposalQueue::rejectDeath()

-{

-    #pragma omp atomic

-    mMinAtoms++;

-}

-

-void ProposalQueue::acceptBirth()

-{

-    #pragma omp atomic

-    mMinAtoms++;

-}

-

-void ProposalQueue::rejectBirth()

-{

-    #pragma omp atomic

-    mMaxAtoms--;

-}

-

-float ProposalQueue::deathProb(uint64_t nAtoms) const

-{

-    double size = static_cast<double>(mDomainLength);

-    double term1 = (size - static_cast<double>(nAtoms)) / size;

-    double term2 = mAlpha * static_cast<double>(mNumBins) * term1;

-    return static_cast<double>(nAtoms) / (static_cast<double>(nAtoms) + term2);

-}

-

-bool ProposalQueue::makeProposal(AtomicDomain &domain)

-{

-    // always birth when no atoms exist

-    if (domain.size() == 0)

-    {

-        return birth(domain);

-    }

-

-    float bdProb = domain.size() < 2 ? 0.6667f : 0.5f;

-

-    mU1 = mRng.uniform();

-    mU2 = mRng.uniform();

-

-    float lowerBound = deathProb(domain.size());

-

-    if (mU1 <= bdProb)

-    {

-        return mU2 < lowerBound ? death(domain) : birth(domain);

-    }

-    return (mU1 < 0.75f || mMaxAtoms < 2) ? move(domain) : exchange(domain);

-}

-    

-unsigned ProposalQueue::primaryIndex(uint64_t pos) const

-{

-    return pos / mSecondaryDimLength;

-}

-

-unsigned ProposalQueue::secondaryIndex(uint64_t pos) const

-{

-    return (pos / mBinLength) % mSecondaryDimSize;

-}

-

-// TODO add atoms with empty mass? fill in mass in gibbssampler?

-// inserting invalidates previous pointers, but not inserting

-// prevents them from being selected for death

-bool ProposalQueue::birth(AtomicDomain &domain)

-{

-    uint64_t pos = domain.randomFreePosition();

-    if (mUsedIndices.contains(primaryIndex(pos)))

-    {

-        return false; // matrix conflict - can't compute gibbs mass

-    }

-

-    mQueue.push_back(AtomicProposal('B', pos));

-    mUsedIndices.insert(primaryIndex(pos));

-    mUsedPositions.insert(pos);

-    ++mMaxAtoms;

-    return true;

-}

-

-bool ProposalQueue::death(AtomicDomain &domain)

-{

-    Atom* a = domain.randomAtom();

-    if (mUsedIndices.contains(primaryIndex(a->pos)))

-    {

-        return false; // matrix conflict - can't compute gibbs mass or deltaLL

-    }

-

-    mQueue.push_back(AtomicProposal('D', a));

-    mUsedIndices.insert(primaryIndex(a->pos));

-    mUsedPositions.insert(a->pos);

-    --mMinAtoms;

-    return true;

-}

-

-bool ProposalQueue::move(AtomicDomain &domain)

-{

-    AtomNeighborhood hood = domain.randomAtomWithNeighbors();

-    uint64_t lbound = hood.hasLeft() ? hood.left->pos : 0;

-    uint64_t rbound = hood.hasRight() ? hood.right->pos : mDomainLength;

-

-    if (!mUsedPositions.isEmptyInterval(lbound, rbound))

-    {

-        return false; // atomic conflict - don't know neighbors

-    }

-

-    uint64_t newLocation = mRng.uniform64(lbound + 1, rbound - 1);

-

-    if (primaryIndex(hood.center->pos) == primaryIndex(newLocation)

-    && secondaryIndex(hood.center->pos) == secondaryIndex(newLocation))

-    {

-        hood.center->pos = newLocation; // automatically accept moves in same bin

-        return true;

-    }

-

-    if (mUsedIndices.contains(primaryIndex(hood.center->pos))

-    || mUsedIndices.contains(primaryIndex(newLocation)))

-    {

-        return false; // matrix conflict - can't compute deltaLL

-    }

-

-    mQueue.push_back(AtomicProposal('M', hood.center, newLocation));

-    mUsedIndices.insert(primaryIndex(hood.center->pos));

-    mUsedIndices.insert(primaryIndex(newLocation));

-    mUsedPositions.insert(hood.center->pos);

-    mUsedPositions.insert(newLocation);

-    return true;

-}

-

-bool ProposalQueue::exchange(AtomicDomain &domain)

-{

-    AtomNeighborhood hood = domain.randomAtomWithRightNeighbor();

-    Atom* a1 = hood.center;

-    Atom* a2 = hood.hasRight() ? hood.right : domain.front();

-

-    if (hood.hasRight()) // has neighbor

-    {

-        if (!mUsedPositions.isEmptyInterval(a1->pos, a2->pos))

-        {

-            return false; // atomic conflict - don't know right neighbor

-        }

-    }

-    else // exchange with first atom

-    {

-        if (!mUsedPositions.isEmptyInterval(a1->pos, mDomainLength))

-        {

-            return false; // atomic conflict - don't know right neighbor

-        }

-        

-        if (!mUsedPositions.isEmptyInterval(0, domain.front()->pos))

-        {

-            return false; // atomic conflict - don't know right neighbor

-        }

-    }

-

-    if (primaryIndex(a1->pos) == primaryIndex(a2->pos)

-    && secondaryIndex(a1->pos) == secondaryIndex(a2->pos))

-    {

-        return true; // TODO automatically accept exchanges in same bin

-    }

-

-    if (mUsedIndices.contains(primaryIndex(a1->pos))

-    || mUsedIndices.contains(primaryIndex(a2->pos)))

-    {

-        return false; // matrix conflict - can't compute gibbs mass or deltaLL

-    }

-

-    mQueue.push_back(AtomicProposal('E', a1, a2));

-    mUsedIndices.insert(primaryIndex(a1->pos));

-    mUsedIndices.insert(primaryIndex(a2->pos));

-    mUsedPositions.insert(a1->pos);

-    mUsedPositions.insert(a2->pos);

-    --mMinAtoms;

-    return true;

-}

-

-Archive& operator<<(Archive &ar, ProposalQueue &q)

-{

-    ar << q.mMinAtoms << q.mMaxAtoms << q.mNumBins << q.mBinLength

-        << q.mSecondaryDimLength << q.mDomainLength << q.mSecondaryDimSize

-        << q.mAlpha << q.mRng;

-    return ar;

-}

-

-Archive& operator>>(Archive &ar, ProposalQueue &q)

-{

-    ar >> q.mMinAtoms >> q.mMaxAtoms >> q.mNumBins >> q.mBinLength

-        >> q.mSecondaryDimLength >> q.mDomainLength >> q.mSecondaryDimSize

-        >> q.mAlpha >> q.mRng;

-    return ar;

-}

deleted file mode 100644

@@ -1,89 +0,0 @@

-#ifndef __GAPS_PROPOSAL_QUEUE_H__

-#define __GAPS_PROPOSAL_QUEUE_H__

-

-#include "utils/Archive.h"

-#include "AtomicDomain.h"

-#include "data_structures/EfficientSets.h"

-#include "math/Random.h"

-

-#include <cstddef>

-#include <stdint.h>

-#include <vector>

-

-struct AtomicProposal

-{

-    char type;

-    uint64_t birthPos; // used in birth

-    uint64_t moveDest; // used in move

-

-    Atom *atom1; // used in death, move, exchange

-    Atom *atom2; // used in exchange

-

-    mutable GapsRng rng;

-

-    AtomicProposal(char t, uint64_t pos); // birth

-    AtomicProposal(char t, Atom *atom); // death

-    AtomicProposal(char t, Atom *atom, uint64_t dest); // move

-    AtomicProposal(char t, Atom *a1, Atom *a2); // exchange

-};

-

-class ProposalQueue

-{

-public:

-

-    ProposalQueue(unsigned primaryDimSize, unsigned secondaryDimSize);

-    void setAlpha(float alpha);

-

-    // modify/access queue

-    void populate(AtomicDomain &domain, unsigned limit);

-    void clear();

-    unsigned size() const;

-    AtomicProposal& operator[](int n);

-

-    // update min/max atoms

-    void acceptDeath();

-    void rejectDeath();

-    void acceptBirth();

-    void rejectBirth();

-

-private:

-

-    std::vector<AtomicProposal> mQueue; // not really a queue for now

-    

-    IntFixedHashSet mUsedIndices;

-    IntDenseOrderedSet mUsedPositions;

-

-    uint64_t mMinAtoms;

-    uint64_t mMaxAtoms;

-

-    unsigned mNumBins; // number of matrix elements

-    uint64_t mBinLength; // atomic length of one bin

-    uint64_t mSecondaryDimLength; // atomic length of one row (col) for A (P)

-    uint64_t mDomainLength; // length of entire atomic domain

-    unsigned mSecondaryDimSize; // number of cols (rows) for A (P)

-

-    float mAlpha;

-

-    mutable GapsRng mRng;

-

-    float mU1;

-    float mU2;

-    bool mUseCachedRng;

-

-    unsigned primaryIndex(uint64_t pos) const;

-    unsigned secondaryIndex(uint64_t pos) const;

-

-    float deathProb(uint64_t nAtoms) const;

-    bool birth(AtomicDomain &domain);

-    bool death(AtomicDomain &domain);

-    bool move(AtomicDomain &domain);

-    bool exchange(AtomicDomain &domain);

-

-    bool makeProposal(AtomicDomain &domain);

-

-    // serialization

-    friend Archive& operator<<(Archive &ar, ProposalQueue &queue);

-    friend Archive& operator>>(Archive &ar, ProposalQueue &queue);

-};

-

-#endif

\ No newline at end of file

@@ -148,7 +148,7 @@ bool gaps::algo::isVectorZero(const float *vec, unsigned size)

 AlphaParameters gaps::algo::alphaParameters(unsigned size, const float *D,

 const float *S, const float *AP, const float *mat)

 {

-    gaps::simd::packedFloat ratio, pMat, pD, pAP, pS;

+    gaps::simd::packedFloat pMat, pD, pAP, pS;

     gaps::simd::packedFloat partialS(0.f), partialSU(0.f);

     gaps::simd::Index i(0);

     for (; i <= size - i.increment(); ++i)

@@ -157,25 +157,24 @@ const float *S, const float *AP, const float *mat)

         pD.load(D + i);

         pAP.load(AP + i);

         pS.load(S + i);

-        ratio = pMat / pS;

-        partialS += ratio * ratio;

-        partialSU += (ratio * (pD - pAP)) / pS;

+        gaps::simd::packedFloat ratio(pMat / (pS * pS));

+        partialS += pMat * ratio;

+        partialSU += ratio * (pD - pAP);

     }

-    float fratio, s = partialS.scalar(), su = partialSU.scalar();

+    float s = partialS.scalar(), su = partialSU.scalar();

     for (unsigned j = i.value(); j < size; ++j)

     {

-        fratio = mat[j] / S[j]; // can save one division here by dividing by S^2

-        s += fratio * fratio;

-        su += (fratio * (D[j] - AP[j])) / S[j];

+        float ratio = mat[j] / (S[j] * S[j]);

+        s += mat[j] * ratio;

+        su += ratio * (D[j] - AP[j]);

     }

     return AlphaParameters(s,su);

 }

-//

 AlphaParameters gaps::algo::alphaParameters(unsigned size, const float *D,

 const float *S, const float *AP, const float *mat1, const float *mat2)

 {

-    gaps::simd::packedFloat ratio, pMat1, pMat2, pD, pAP, pS;

+    gaps::simd::packedFloat pMat1, pMat2, pD, pAP, pS;

     gaps::simd::packedFloat partialS(0.f), partialSU(0.f);

     gaps::simd::Index i(0);

     for (; i <= size - i.increment(); ++i)

@@ -185,17 +184,44 @@ const float *S, const float *AP, const float *mat1, const float *mat2)

         pD.load(D + i);

         pAP.load(AP + i);

         pS.load(S + i);

-        ratio = (pMat1 - pMat2) / pS;

-        partialS += ratio * ratio;

-        partialSU += ratio * (pD - pAP) / pS;

+        gaps::simd::packedFloat ratio((pMat1 - pMat2) / (pS * pS));

+        partialS += (pMat1 - pMat2) * ratio;

+        partialSU += ratio * (pD - pAP);

     }

-    float fratio, s = partialS.scalar(), su = partialSU.scalar();

+    float s = partialS.scalar(), su = partialSU.scalar();

     for (unsigned j = i.value(); j < size; ++j)

     {

-        fratio = (mat1[j] - mat2[j]) / S[j];

-        s += fratio * fratio;

-        su += fratio * (D[j] - AP[j]) / S[j];

+        float ratio = (mat1[j] - mat2[j]) / (S[j] * S[j]);

+        s += (mat1[j] - mat2[j]) * ratio;

+        su += ratio * (D[j] - AP[j]);

+    }

+    return AlphaParameters(s,su);

+}

+

+AlphaParameters gaps::algo::alphaParametersWithChange(unsigned size,

+const float *D, const float *S, const float *AP, const float *mat, float ch)

+{

+    gaps::simd::packedFloat pCh(ch);

+    gaps::simd::packedFloat pMat, pD, pAP, pS;

+    gaps::simd::packedFloat partialS(0.f), partialSU(0.f);

+    gaps::simd::Index i(0);

+    for (; i <= size - i.increment(); ++i)

+    {   

+        pMat.load(mat + i);

+        pD.load(D + i);

+        pAP.load(AP + i);

+        pS.load(S + i);

+        gaps::simd::packedFloat ratio(pMat / (pS * pS));

+        partialS += pMat * ratio;

+        partialSU += ratio * (pD - (pAP + pCh * pMat));

+    }

+    float s = partialS.scalar(), su = partialSU.scalar();

+    for (unsigned j = i.value(); j < size; ++j)

+    {

+        float ratio = mat[j] / (S[j] * S[j]);

+        s += mat[j] * ratio;

+        su += ratio * (D[j] - (AP[j] + ch * mat[j]));

     }

     return AlphaParameters(s,su);

 }

@@ -72,6 +72,9 @@ namespace algo

     AlphaParameters alphaParameters(unsigned size, const float *D,

         const float *S, const float *AP, const float *mat);

+    AlphaParameters alphaParametersWithChange(unsigned size, const float *D,

+        const float *S, const float *AP, const float *mat, float d);

+

     AlphaParameters alphaParameters(unsigned size, const float *D,

         const float *S, const float *AP, const float *mat1, const float *mat2);

@@ -9,11 +9,18 @@

 struct OptionalFloat

 {

-    float value;

-    bool hasValue;

+public :

-    OptionalFloat() : hasValue(false), value(0.f) {}

-    OptionalFloat(float f) : hasValue(true), value(f) {}

+    OptionalFloat() : mHasValue(false), mValue(0.f) {}

+    OptionalFloat(float f) : mHasValue(true), mValue(f) {}

+

+    float value() { return mValue; }

+    bool hasValue() const { return mHasValue; }

+

+private :

+

+    float mValue;

+    bool mHasValue;

 };

 namespace gaps