cmnRandomSequence.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */

/*

  Author(s):  Ofri Sadowsky, Anton Deguet
  Created on: 2003-06-09

  (C) Copyright 2003-2013 Johns Hopkins University (JHU), All Rights
  Reserved.

--- begin cisst license - do not edit ---

This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.

--- end cisst license ---

*/


#pragma once

#ifndef _cmnRandomSequence_h
#define _cmnRandomSequence_h

#include <cisstCommon/cmnPortability.h>

#include <stdlib.h>
#include <cstddef>

#include <cisstCommon/cmnExport.h>

class CISST_EXPORT cmnRandomSequence
{
public:
    typedef unsigned int SeedType;

    typedef int ElementaryRandomNumber;

    typedef unsigned long SequenceCounterType;

    static const SeedType DefaultSeed;

    static const ElementaryRandomNumber LowerRandomBound;

    static const ElementaryRandomNumber UpperRandomBound;

protected:
    cmnRandomSequence() {
        SetSeed(DefaultSeed);
    }

    cmnRandomSequence(const SeedType seed, const SequenceCounterType position = 0) {
        SetSeed(seed);
        SetSequencePosition(position);
    }

    cmnRandomSequence(const cmnRandomSequence & other) {
        SetSeed(other.GetSeed());
        SetSequencePosition(other.GetSequencePosition());
    }

    cmnRandomSequence & operator=(const cmnRandomSequence & other) {
        SetSeed(other.GetSeed());
        SetSequencePosition(other.GetSequencePosition());
        return *this;
    }

    static cmnRandomSequence RandomInstance;

public:
    static cmnRandomSequence & GetInstance(void) {
        return RandomInstance;
    }

    SeedType GetSeed(void) const {
        return Seed;
    }

    void SetSeed(const SeedType seed) {
        Seed = seed;
        SequencePosition = 0;
        srand(Seed);
    }

    SequenceCounterType GetSequencePosition(void) const {
        return SequencePosition;
    }

    void SetSequencePosition(const SequenceCounterType position) {
        SetSeed(GetSeed());
        while (GetSequencePosition() < position) {
            ExtractRandomElement();
        }
    }


    ElementaryRandomNumber ExtractRandomElement(void) {
        ++SequencePosition;
        return rand();
    }


    template <typename _valueType>
    void ExtractRandomValue(_valueType & result);

    template <typename _valueType>
    inline void ExtractRandomValue(const _valueType min, const _valueType max, _valueType & result);

    template <typename _valueType>
    inline void ExtractRandomValueArray(const _valueType min, const _valueType max, _valueType * array,
                                        const size_t arraySize);

    float ExtractRandomFloat(void) {
      ElementaryRandomNumber randomNumber = ExtractRandomElement();
      float myPosition = static_cast<float>(randomNumber) - static_cast<float>(LowerRandomBound);
      float randomFloat = myPosition / (static_cast<float>(UpperRandomBound) - static_cast<float>(LowerRandomBound) + 1);
      return randomFloat;
    }
    float ExtractRandomFloat(const float min, const float max) {
        const float randomFloat = ExtractRandomFloat();
        return (randomFloat * (max - min)) + min;
    }
    void ExtractRandomFloatArray(const float min, const float max, float * array,
                                 const size_t arraySize) {
        for (size_t i = 0; i < arraySize; ++i, ++array) {
            *array = ExtractRandomFloat(min, max);
        }
    }

    double ExtractRandomDouble(void) {
        return (static_cast<double>(ExtractRandomElement()) - static_cast<double>(LowerRandomBound)) / (static_cast<double>(UpperRandomBound) - static_cast<double>(LowerRandomBound) + 1);
    }
    double ExtractRandomDouble(const double min, const double max) {
        const double randomDouble = ExtractRandomDouble();
        return (randomDouble * (max - min)) + min;
    }
    void ExtractRandomDoubleArray(const double min, const double max, double *array,
                                  const size_t arraySize) {
        for (size_t i = 0; i < arraySize; ++i, ++array) {
            *array = ExtractRandomDouble(min, max);
        }
    }

    int ExtractRandomInt(void) {
        return ExtractRandomElement();
    }
    int ExtractRandomInt(const int min, const int max) {
        const float randomFloat = ExtractRandomFloat();
        return static_cast<int>((randomFloat * (max - min)) + min);    }

    void ExtractRandomIntArray(const int min, const int max, int *array,
                               const size_t arraySize) {
        for (size_t i = 0; i < arraySize; ++i, ++array) {
            *array = ExtractRandomInt(min, max);
        }
    }

    unsigned int ExtractRandomUnsignedInt(void) {
        int randomInt = ExtractRandomElement();
        return static_cast<unsigned int>(randomInt);
    }
    unsigned int ExtractRandomUnsignedInt(const unsigned int min, const unsigned int max) {
        const float randomFloat = ExtractRandomFloat();
        return static_cast<unsigned int>((randomFloat * (max - min)) + min);
    }
    void ExtractRandomUnsignedIntArray(const unsigned int min, const unsigned int max, unsigned int *array,
                                       const size_t arraySize) {
        for (size_t i = 0; i < arraySize; ++i, ++array) {
            *array = ExtractRandomUnsignedInt(min, max);
        }
    }

    short ExtractRandomShort(void) {
        return static_cast<short>(ExtractRandomElement()&0xffff);
    }
    short ExtractRandomShort(const short min, const short max) {
        const float randomFloat = ExtractRandomFloat();
        return static_cast<short>((randomFloat * (max - min)) + min);
    }
    void ExtractRandomShortArray(const short min, const short max, short *array,
                                 const size_t arraySize) {
        for (size_t i = 0; i < arraySize; ++i, ++array) {
            *array = ExtractRandomShort(min, max);
        }
    }

    unsigned short ExtractRandomUnsignedShort(void) {
        int randomInt = ExtractRandomElement();
        return static_cast<unsigned short>((0xff) & randomInt);
    }
    unsigned short ExtractRandomUnsignedShort(const unsigned short min, const unsigned short max) {
        const float randomFloat = ExtractRandomFloat();
        return static_cast<unsigned short>((randomFloat * (max - min)) + min);
    }
    void ExtractRandomUnsignedShortArray(const unsigned short min, const unsigned short max, unsigned short *array,
                                         const size_t arraySize) {
        for (size_t i = 0; i < arraySize; ++i, ++array) {
            *array = ExtractRandomUnsignedShort(min, max);
        }
    }

    inline long ExtractRandomLong(void) {
#if (CISST_DATA_MODEL == CISST_LP64)
        // long are 64 bits so we can cast from long long
        return ExtractRandomLongLong();
#else
        // long are 32 bits so we can cast from int
        return ExtractRandomInt();
#endif
    }
    inline long ExtractRandomLong(const long min, const long max) {
        const float randomFloat = ExtractRandomFloat();
        return static_cast<long>((randomFloat * (max - min)) + min);
    }
    inline void ExtractRandomLongArray(const long min, const long max, long * array,
                                       const size_t arraySize) {
        for (size_t i = 0; i < arraySize; ++i, ++array)
            *array = ExtractRandomLong(min, max);
    }

    inline unsigned long ExtractRandomUnsignedLong(void) {
#if (CISST_DATA_MODEL == CISST_LP64)
        // long are 64 bits so we can cast from long long
        return ExtractRandomUnsignedLongLong();
#else
        // long are 32 bits so we can cast from int
        return ExtractRandomUnsignedInt();
#endif

    }
    inline unsigned long ExtractRandomUnsignedLong(const unsigned long min, const unsigned long max) {
        const double randomDouble = ExtractRandomDouble();
        return static_cast<unsigned long >((randomDouble * (max - min)) + min);
    }
    inline void ExtractRandomUnsignedLongArray(const unsigned long min, const unsigned long max, unsigned long * array,
                                               const size_t arraySize) {
        for (size_t i = 0; i < arraySize; ++i, ++array) {
            *array = ExtractRandomUnsignedLong(min, max);
        }
    }

    inline long long ExtractRandomLongLong(void) {
        // create 64 random bits
        long long int result;
        int * part = reinterpret_cast<int *>(&result);
        *part = ExtractRandomElement();
        part++;
        *part = ExtractRandomElement();
        return result;

    }
    inline long ExtractRandomLongLong(const long long min, const long long max) {
        const float randomFloat = ExtractRandomFloat();
        return static_cast<long long>((randomFloat * (max - min)) + min);
    }
    inline void ExtractRandomLongLongArray(const long long min, const long long max, long long * array,
                                           const size_t arraySize) {
        for (size_t i = 0; i < arraySize; ++i, ++array) {
            *array = ExtractRandomLongLong(min, max);
        }
    }

    inline unsigned long long ExtractRandomUnsignedLongLong(void) {
        // create 64 random bits
        unsigned long long int result;
        int * part = reinterpret_cast<int *>(&result);
        *part = ExtractRandomElement();
        part++;
        *part = ExtractRandomElement();
        return result;
    }
    inline unsigned long long ExtractRandomUnsignedLongLong(const unsigned long long min, const unsigned long long max) {
        const double randomDouble = ExtractRandomDouble();
        return static_cast<unsigned long long >((randomDouble * (max - min)) + min);
    }
    inline void ExtractRandomUnsignedLongLongArray(const unsigned long long min, const unsigned long long max, unsigned long long * array,
                                                   const size_t arraySize) {
        for (size_t i = 0; i < arraySize; ++i, ++array) {
            *array = ExtractRandomUnsignedLongLong(min, max);
        }
    }

    char ExtractRandomChar(void) {
        int randomInt = ExtractRandomElement();
        return static_cast<char>((0xff) & randomInt);
    }
    char ExtractRandomChar(const char min, const char max) {
        const float randomFloat = ExtractRandomFloat();
        return static_cast<char>((randomFloat * (max - min)) + min);
    }
    void ExtractRandomCharArray(const char min, const char max, char *array,
                                const size_t arraySize) {
        for (size_t i = 0; i < arraySize; ++i, ++array) {
            *array = ExtractRandomChar(min, max);
        }
    }

    unsigned char ExtractRandomUnsignedChar(void) {
        int randomInt = ExtractRandomElement();
        return static_cast<unsigned char>((0xff) & randomInt);
    }
    unsigned char ExtractRandomUnsignedChar(const unsigned char min, const unsigned char max) {
        const float randomFloat = ExtractRandomFloat();
        return static_cast<unsigned char>((randomFloat * (max - min)) + min);
    }
    void ExtractRandomUnsignedCharArray(const unsigned char min, const unsigned char max, unsigned char *array,
                                        const size_t arraySize) {
        for (size_t i = 0; i < arraySize; ++i, ++array) {
            *array = ExtractRandomUnsignedChar(min, max);
        }
    }

    void ExtractRandomPermutation(const size_t length, size_t * array);

    size_t ExtractRandomSizeT(const size_t min, const size_t max) {
        const float randomFloat = ExtractRandomFloat();
        return static_cast<size_t>((randomFloat * (max - min)) + min);
    }
    void ExtractRandomSizeTArray(const size_t min, const size_t max, size_t * array,
                                 const size_t arraySize) {
        for (size_t i = 0; i < arraySize; ++i, ++array) {
            *array = ExtractRandomSizeT(min, max);
        }
    }

    ptrdiff_t ExtractRandomPtrdiffT(const ptrdiff_t min, const ptrdiff_t max) {
        const float randomFloat = ExtractRandomFloat();
        return static_cast<ptrdiff_t>((randomFloat * (max - min)) + min);
    }
    void ExtractRandomPtrdiffTArray(const ptrdiff_t min, const ptrdiff_t max, ptrdiff_t * array,
                                    const size_t arraySize) {
        for (size_t i = 0; i < arraySize; ++i, ++array) {
            *array = ExtractRandomPtrdiffT(min, max);
        }
    }

private:
    SeedType Seed;

    SequenceCounterType SequencePosition;

};


/* Specializations of cmnRandomSequence::ExtractRandomValue */
#ifndef DOXYGEN
/* --- float --- */
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<float>(float & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<float>(const float min, const float max, float & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValueArray<float>(const float min, const float max, float * array,
                                                       const size_t arraySize);

/* --- double --- */
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<double>(double & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<double>(const double min, const double max, double & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValueArray<double>(const double min, const double max, double * array,
                                                        const size_t arraySize);

/* --- int --- */
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<int>(int & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<int>(const int min, const int max, int & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValueArray<int>(const int min, const int max, int * array,
                                                     const size_t arraySize);
/* --- unsigned int --- */
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<unsigned int>(unsigned int & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<unsigned int>(const unsigned int min, const unsigned int max, unsigned int & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValueArray<unsigned int>(const unsigned int min, const unsigned int max, unsigned int * array,
                                                              const size_t arraySize);

/* --- short --- */
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<short>(short & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<short>(const short min, const short max, short & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValueArray<short>(const short min, const short max, short * array,
                                                       const size_t arraySize);
/* --- unsigned short --- */
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<unsigned short>(unsigned short & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<unsigned short>(const unsigned short min, const unsigned short max, unsigned short & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValueArray<unsigned short>(const unsigned short min, const unsigned short max, unsigned short * array,
                                                                const size_t arraySize);

/* --- long --- */
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<long>(long & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<long>(const long min, const long max, long & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValueArray<long>(const long min, const long max, long * array,
                                                      const size_t arraySize);

/* --- unsigned long --- */
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<unsigned long>(unsigned long & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<unsigned long>(const unsigned long min, const unsigned long max, unsigned long & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValueArray<unsigned long>(const unsigned long min, const unsigned long max, unsigned long * array,
                                                               const size_t arraySize);

/* --- long long --- */
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<long long>(long long & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<long long>(const long long min, const long long max, long long & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValueArray<long long>(const long long min, const long long max, long long * array,
                                                           const size_t arraySize);

/* --- unsigned long long --- */
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<unsigned long long>(unsigned long long & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<unsigned long long>(const unsigned long long min, const unsigned long long max, unsigned long long & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValueArray<unsigned long long>(const unsigned long long min, const unsigned long long max, unsigned long long * array,
                                                                    const size_t arraySize);

/* --- char --- */
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<char>(char & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<char>(const char min, const char max, char & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValueArray<char>(const char min, const char max, char * array,
                                                      const size_t arraySize);

/* --- unsigned char --- */
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<unsigned char>(unsigned char & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<unsigned char>(const unsigned char min, const unsigned char max, unsigned char & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValueArray<unsigned char>(const unsigned char min, const unsigned char max, unsigned char * array,
                                                               const size_t arraySize);

/* --- bool --- */
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<bool>(bool & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValue<bool>(const bool min, const bool max, bool & result);
CISST_DECLARE_TEMPLATE_FUNCTION_SPECIALIZATION
void cmnRandomSequence::ExtractRandomValueArray<bool>(const bool min, const bool max, bool * array,
                                                      const size_t arraySize);


/* --- float ---*/
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(float & result) {
    result = ExtractRandomFloat();
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(const float min, const float max, float & result) {
    result = ExtractRandomFloat(min, max);
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValueArray(const float min, const float max, float * array,
                                                       const size_t arraySize) {
    ExtractRandomFloatArray(min, max, array, arraySize);
}

/* --- double ---*/
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(double & result) {
    result = ExtractRandomDouble();
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(const double min, const double max, double & result) {
    result = ExtractRandomDouble(min, max);
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValueArray(const double min, const double max, double * array,
                                                       const size_t arraySize) {
    ExtractRandomDoubleArray(min, max, array, arraySize);
}

/* --- int ---*/
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(int & result) {
    result = ExtractRandomInt();
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(const int min, const int max, int & result) {
    result = ExtractRandomInt(min, max);
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValueArray(const int min, const int max, int * array,
                                                       const size_t arraySize) {
    ExtractRandomIntArray(min, max, array, arraySize);
}
/* --- unsigned int ---*/
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(unsigned int & result) {
    result = ExtractRandomUnsignedInt();
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(const unsigned int min, const unsigned int max, unsigned int & result) {
    result = ExtractRandomUnsignedInt(min, max);
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValueArray(const unsigned int min, const unsigned int max, unsigned int * array,
                                                       const size_t arraySize) {
    ExtractRandomUnsignedIntArray(min, max, array, arraySize);
}

/* --- long ---*/
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(long & result) {
    result = ExtractRandomLong();
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(const long min, const long max, long & result) {
    result = ExtractRandomLong(min, max);
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValueArray(const long min, const long max, long * array,
                                                       const size_t arraySize) {
    ExtractRandomLongArray(min, max, array, arraySize);
}
/* --- unsigned long ---*/
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(unsigned long & result) {
    result = ExtractRandomUnsignedLong();
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(const unsigned long min, const unsigned long max, unsigned long & result) {
    result = ExtractRandomUnsignedLong(min, max);
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValueArray(const unsigned long min, const unsigned long max, unsigned long * array,
                                                       const size_t arraySize) {
    ExtractRandomUnsignedLongArray(min, max, array, arraySize);
}

/* --- long long ---*/
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(long long & result) {
    result = ExtractRandomLongLong();
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(const long long min, const long long max, long long & result) {
    result = ExtractRandomLongLong(min, max);
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValueArray(const long long min, const long long max, long long * array,
                                                       const size_t arraySize) {
    ExtractRandomLongLongArray(min, max, array, arraySize);
}
/* --- unsigned long long ---*/
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(unsigned long long & result) {
    result = ExtractRandomUnsignedLongLong();
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(const unsigned long long min, const unsigned long long max, unsigned long long & result) {
    result = ExtractRandomUnsignedLongLong(min, max);
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValueArray(const unsigned long long min, const unsigned long long max, unsigned long long * array,
                                                       const size_t arraySize) {
    ExtractRandomUnsignedLongLongArray(min, max, array, arraySize);
}


/* --- short ---*/
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(short & result) {
    result = ExtractRandomShort();
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(const short min, const short max, short & result) {
    result = ExtractRandomShort(min, max);
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValueArray(const short min, const short max, short * array,
                                                       const size_t arraySize) {
    ExtractRandomShortArray(min, max, array, arraySize);
}
/* --- unsigned short ---*/
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(unsigned short & result) {
    result = ExtractRandomUnsignedShort();
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(const unsigned short min, const unsigned short max, unsigned short & result) {
    result = ExtractRandomUnsignedShort(min, max);
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValueArray(const unsigned short min, const unsigned short max, unsigned short * array,
                                                       const size_t arraySize) {
    ExtractRandomUnsignedShortArray(min, max, array, arraySize);
}

/* --- char --- */
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(char & result) {
    result = ExtractRandomChar();
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(const char min, const char max, char & result) {
    result = ExtractRandomChar(min, max);
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValueArray(const char min, const char max, char * array, const size_t arraySize) {
    ExtractRandomCharArray(min, max, array, arraySize);
}
/* --- unsigned char --- */
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(unsigned char & result) {
    result = ExtractRandomUnsignedChar();
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(const unsigned char min, const unsigned char max, unsigned char & result) {
    result = ExtractRandomUnsignedChar(min, max);
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValueArray(const unsigned char min, const unsigned char max, unsigned char * array,
                                                       const size_t arraySize) {
    ExtractRandomUnsignedCharArray(min, max, array, arraySize);
}

/* --- bool --- */
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(bool & result) {
    int value = ExtractRandomInt(0, 1024);
    result = value & 1;
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValue(const bool min, const bool max, bool & result) {
    if (min == max) {
        result = min;
    } else {
        ExtractRandomValue(result);
    }
}
CISST_DEFINE_TEMPLATE_FUNCTION_SPECIALIZATION
inline void cmnRandomSequence::ExtractRandomValueArray(const bool min, const bool max, bool * array,
                                                       const size_t arraySize) {
    for (size_t i = 0; i < arraySize; ++i, ++array) {
        ExtractRandomValue(min, max, *array);
    }
}

#endif // DOXYGEN

#endif  // _cmnRandomSequence_h