Class ScalesState

src/modules/convex/utils_regularization.cpp:17–75

template <class Handle>
class ScalesState
{
    template <class OtherHandle> friend class ScalesState;

  public:
    ScalesState (const AnyType& inArray):
        mStorage(inArray.getAs<Handle>())
    {
        rebind();
    }

    inline operator AnyType () const
    {
        return mStorage;
    }

    inline void allocate (const Allocator& inAllocator,
                          uint32_t inDimension)
    {
        mStorage = inAllocator.allocateArray<double,
                                             dbal::AggregateContext,
                                             dbal::DoZero,
                                             dbal::ThrowBadAlloc>(
                                                 arraySize(inDimension));
        dimension.rebind(&mStorage[0]);
        dimension = inDimension;
        rebind();
    }

    template <class OtherHandle>
    ScalesState& operator= (const ScalesState<OtherHandle>& inOtherState)
    {
        for (size_t i = 0; i < mStorage.size(); i++)
            mStorage[i] = inOtherState.mStorage[i];
        return *this;
    }

    static inline uint32_t arraySize (const uint32_t inDimension)
    {
        return 2 + 2 * inDimension;
    }

  protected:
    void rebind ()
    {
        dimension.rebind(&mStorage[0]);
        numRows.rebind(&mStorage[1]);
        mean.rebind(&mStorage[2], dimension);
        std.rebind(&mStorage[2 + dimension], dimension);
    }

    Handle mStorage;

  public:
    typename HandleTraits<Handle>::ReferenceToUInt32 dimension;
    typename HandleTraits<Handle>::ReferenceToUInt64 numRows;
    typename HandleTraits<Handle>::ColumnVectorTransparentHandleMap mean;
    typename HandleTraits<Handle>::ColumnVectorTransparentHandleMap std;