SourceForge.jp

dKingyoRandom_MT_SSE2.h

説明を見る。
00001 
00002 
00003 #ifndef _dKingyoRandom_MT_SSE2__h
00004 #define _dKingyoRandom_MT_SSE2__h
00005 
00006 #include <mymt.h>
00007 //#include "../global.h"
00008 #include "dkutilMath.h"
00009 
00010 //#pragma warning(push:4146)
00011 #pragma warning(disable:4146)
00012 /*
00013     int i, ret;
00014     myMT_t *mt;
00015 
00016     mt = myMT_Init();
00017     myMT_SetSeed(mt, SEED);
00018 
00019     printf("test of myMT\n");
00020     for (i = 0; i < 16; i++) {
00021         int j;
00022         for (j = 0; j < 4; j++) {
00023             printf("%08X", myMT_GetInt32(mt));
00024         }
00025         printf("\n");
00026     }
00027 
00028     myMT_SetSeed(mt, SEED);
00029     elapsed();
00030     ret = 0;
00031     for (i = 0; i < 100000000; i++) {
00032         ret += myMT_GetInt32(mt);
00033     }
00034     printf("asm version ret=%08X  %ftime\n", ret, elapsed());
00035 
00036     if (0) {
00037         unsigned int seed[624];
00038         memset(seed, 2, sizeof(seed));
00039         seed[0] = 1;
00040         myMT_SetSeeds(mt, seed, 624);
00041         ret = 0;
00042         for (i = 0; i < 10000000; i++) { ret += myMT_GetInt32(mt); }
00043         printf("ret=%08X\n", myMT_GetInt32(mt));
00044 
00045         myMT_SetSeeds(mt, seed, 623);
00046         ret = 0;
00047         for (i = 0; i < 10000000; i++) { ret += myMT_GetInt32(mt); }
00048         printf("ret=%08X\n", myMT_GetInt32(mt));
00049 
00050         seed[623] = 1;
00051         myMT_SetSeeds(mt, seed, 624);
00052         ret = 0;
00053         for (i = 0; i < 10000000; i++) { ret += myMT_GetInt32(mt); }
00054         printf("ret=%08X\n", myMT_GetInt32(mt));
00055     }
00056 
00057     myMT_Term(mt);
00058     
00059 */
00060 namespace dkutil{//begin dkutil namespace
00061     namespace oldmath{//begin math namespace
00062 
00063 
00064 template<class T,DWORD RANDMAX_ = INT_MAX>
00065 class INL_dKingyoRandom_MT_SSE2{
00066 protected:
00067     myMT_t *mt;
00068     ULONG m_ulSeed;
00069     DWORD m_Max;
00071     INL_dKingyoRandom_MT_SSE2(INL_dKingyoRandom_MT_SSE2 &c);
00072 public:
00073     
00074     INL_dKingyoRandom_MT_SSE2(T seed=timeGetTime())
00075     {
00076         //seed = ::abs(seed);
00077         if(seed<0){seed = -seed;}
00078         m_Max=RANDMAX_;
00079         //m_Max=RAND_MAX;
00080         m_ulSeed  =static_cast<ULONG>(seed);
00081         mt = myMT_Init();
00082         myMT_SetSeed(mt, (UINT)m_ulSeed);
00083     }
00084 
00085     ~INL_dKingyoRandom_MT_SSE2(){
00086         myMT_Term(mt);
00087     }
00088     inline T Rand(){
00089         return myMT_GetInt32(mt);
00090     }
00091     
00092     inline T Random(DWORD domain){
00093         //return Rand() * domain / m_Max;
00094         return RandomDomain(0,domain);
00095     }
00096     inline  T RandomDomain(T min,T max){
00097 
00098         //return max += Random(max + min);
00099         //return max-=Random(max-min);
00100         //return (max-min)*Rand()+min;
00101         float fNum, fDenom;
00102 
00103             fNum   = (float)Rand() * ( (float)max - (float)min + 1.0f );
00104             fDenom = (float)RANDMAX_ + 1.0f;
00105 
00106             return min + (int)( fNum / fDenom );
00107     }
00108     inline T RandomDomainSafety(T min,T max){
00109         if(min>max){SWAP_NUM(min,max);}
00110         MINMAX_ABS(min,max);
00111         MINMAX_SAFETY(min,max);
00112         return RandomDomain(min,max);
00113     }
00114     inline void SetSeed(UINT seed){
00115         m_ulSeed = seed;
00116         myMT_SetSeed(mt, (UINT)seed);
00117     }
00118     inline ULONG GetSeed(){return m_ulSeed;}
00119     inline DWORD GetRandMax(){return m_Max;}
00120 };
00121 
00122 }//end of math namespace
00123 
00124 namespace oldmath{
00125 
00126 
00127 template<typename T,DWORD RANDMAX_ = INT_MAX>
00128 class dKingyoRandom_MT_SSE2 : public dKingyoRandom_BasicMember<T>{
00129 protected:
00130     INL_dKingyoRandom_MT_SSE2<T,RANDMAX_> mtsse;
00131 public:
00132     dKingyoRandom_MT_SSE2(T seed=timeGetTime())
00133     {       
00134         m_Max = RANDMAX_;//(RAMD_MAX)
00135         seed = ::abs(seed);
00136         //if(seed<0){seed = -seed;}
00137          m_ulSeed = static_cast<ULONG>(m_Seed =seed);
00138         mtsse.SetSeed(m_ulSeed);
00139     }
00140     ~dKingyoRandom_MT_SSE2(){
00141     }
00142     virtual T Rand(){
00143         return mtsse.Rand();
00144     }
00145     
00146     virtual T Random(T domain){
00147         //return Rand() * domain / m_Max;
00148         return mtsse.Random(domain);
00149     }
00150     virtual T RandomDomain(T min,T max){
00151 
00152         //return max += Random(max + min);
00153         //return max-=Random(max-min);
00154         return mtsse.RandomDomain(min,max);
00155 
00156     }
00157     virtual T RandomDomainSafety(T min,T max){
00158         if(min>max){SWAP_NUM(min,max);}
00159         MINMAX_ABS(min,max);
00160         MINMAX_SAFETY(min,max);
00161         return RandomDomain(min,max);
00162     }
00163     virtual void SetSeed(T set){
00164         mtsse.SetSeed((UINT)set);
00165     }
00166     
00167 };
00168 
00169 typedef dKingyoRandom_MT_SSE2<ULONG,ULONG_MAX> dKingyoRandom_MT_SSE2_NO_SETUP;
00170 /*
00171 class dKingyoRandom_MT_SSE2_NO_SETUP : public dKingyoRandom_MT_SSE2<ULONG,ULONG_MAX>{
00172 public:
00173     dKingyoRandom_MT_SSE2_NO_SETUP(){}
00174 };
00175 */
00176 }//end of math namespace
00177 }//end of dkutil namespace
00178 
00179 #pragma warning(default:4146)
00180 //#pragma warning(pop)
00181 
00182 #endif //end of _dKingyoRandom_MT_SSE2__h

dkutil 1.02リリース前 d金魚専用マニュアルバージョンに対してSun Dec 28 21:23:07 2003に生成されました。 doxygen 1.3.5