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__