xsi_random.h

Go to the documentation of this file.

//*****************************************************************************
//*****************************************************************************

#if (_MSC_VER > 1000) || defined(SGI_COMPILER)
#pragma once
#endif

#ifndef __XSIRANDOM_H__
#define __XSIRANDOM_H__

#include "sicppsdk.h"
#include <math.h>

namespace XSI {

namespace MATH {

//*****************************************************************************
//*****************************************************************************
class SICPPSDKDECL CRandom
{
        public:
        SICPPSDK_INLINE CRandom();

        SICPPSDK_INLINE CRandom( LONG in_nSeed );

        SICPPSDK_INLINE CRandom( const CRandom& in_random );

        ~CRandom() {}

        SICPPSDK_INLINE void PutSeed( LONG in_nSeed );

        SICPPSDK_INLINE LONG GetValue() const;

        SICPPSDK_INLINE float GetNormalizedValue() const;

        SICPPSDK_INLINE operator LONG () const;

        void PutIndex( ULONG in_nIndex );

        SICPPSDK_INLINE LONG operator++();

        SICPPSDK_INLINE LONG operator++(int);

        SICPPSDK_INLINE LONG operator--();

        SICPPSDK_INLINE LONG operator--(int);

        SICPPSDK_INLINE void Skip( ULONG in_nOffset );

        private:
        void Init( LONG in_nSeed, short in_nState, ULONG in_nStartIndex );
        LONG GetValue( LONG in_nIndex ) const;
        LONG GetNext( LONG in_nPrev );
        LONG GetPrevious( LONG in_nNext );
        static LONG Skip( LONG in_nValue, ULONG in_nOffset );

        static ULONG Map( LONG in_nUnmapped );
        static LONG Unmap( ULONG in_nMapped );

        mutable enum State
        {
                HAVE_NONE,
                HAVE_INDEX,
                HAVE_INDEX_AND_RND
        } m_eState;

        LONG m_nSeed;
        ULONG m_nIndex;
        mutable LONG m_nRnd;
};

SICPPSDK_INLINE CRandom::CRandom()
{
        Init( 0, HAVE_NONE, 0 );
}

SICPPSDK_INLINE CRandom::CRandom( LONG in_nSeed )
{
        Init( in_nSeed, HAVE_NONE, 0 );
}

SICPPSDK_INLINE CRandom::CRandom( const CRandom& in_random )
{
        m_nSeed = in_random.m_nSeed;
        m_eState = in_random.m_eState;
        m_nIndex = in_random.m_nIndex;
        m_nRnd = in_random.m_nRnd;
}

SICPPSDK_INLINE void CRandom::PutSeed( LONG in_nSeed )
{
        m_nSeed = Map( 0 );
        PutIndex( in_nSeed + 12345 );
        m_nSeed = Map( GetValue() );
}

SICPPSDK_INLINE LONG CRandom::GetValue() const
{
        if ( m_eState < HAVE_INDEX_AND_RND )
        {
                m_nRnd = GetValue( m_nIndex );
                m_eState = HAVE_INDEX_AND_RND;
        }
        return m_nRnd;
}

SICPPSDK_INLINE float CRandom::GetNormalizedValue() const
{
        return (GetValue()/(float)(1<<30));
}

SICPPSDK_INLINE CRandom::operator LONG () const
{
        return GetValue();
}

SICPPSDK_INLINE LONG CRandom::operator++()
{
        ++m_nIndex;
        if ( m_eState >= HAVE_INDEX_AND_RND )
        {
                return m_nRnd = GetNext( m_nRnd );
        }
        return GetValue();
}

SICPPSDK_INLINE LONG CRandom::operator++(int)
{
        ++m_nIndex;
        int nTmp = GetValue();
        m_nRnd = GetNext( m_nRnd );
        return nTmp;
}

SICPPSDK_INLINE LONG CRandom::operator--()
{
        --m_nIndex;
        if ( m_eState >= HAVE_INDEX_AND_RND )
        {
                return m_nRnd = GetPrevious( m_nRnd );
        }

        return GetValue();
}

SICPPSDK_INLINE LONG CRandom::operator--(int)
{
        --m_nIndex;
        LONG nTmp = GetValue();
        m_nRnd = GetPrevious( m_nRnd );
        return nTmp;
}

SICPPSDK_INLINE void CRandom::Skip( ULONG in_nOffset )
{
        PutIndex( m_nIndex + in_nOffset );
}

};
};

#endif // __XSIRANDOM_H__