init
This commit is contained in:
commit
cad98f8211
64 files changed
+5157
No files matched your search
@@ -0,0 +1,230 @@
|
||||
#include <amscppnarray/amscppnarray.hpp>
|
||||
|
||||
namespace ams
|
||||
{
|
||||
namespace narray
|
||||
{
|
||||
|
||||
template<> void narray<float>::print(const int printstyle)
|
||||
{
|
||||
narray_size_t I;
|
||||
|
||||
printf("{");
|
||||
for(I=0;I<this->length-1;I++)
|
||||
{
|
||||
printf("%1.3f,",this->data[I]);
|
||||
}
|
||||
if(this->length>=1) printf("%1.3f",this->data[this->length-1]);
|
||||
printf("}");
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
template<> void narray<double>::print(const int printstyle)
|
||||
{
|
||||
narray_size_t I;
|
||||
|
||||
printf("{");
|
||||
for(I=0;I<this->length-1;I++)
|
||||
{
|
||||
printf("%1.3f,",this->data[I]);
|
||||
}
|
||||
if(this->length>=1) printf("%1.3f",this->data[this->length-1]);
|
||||
printf("}");
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
template<> void narray<int>::print(const int printstyle)
|
||||
{
|
||||
narray_size_t I;
|
||||
|
||||
printf("{");
|
||||
for(I=0;I<this->length-1;I++)
|
||||
{
|
||||
printf("%d,",this->data[I]);
|
||||
}
|
||||
if(this->length>=1) printf("%d",this->data[this->length-1]);
|
||||
printf("}");
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
template<> void narray<long>::print(const int printstyle)
|
||||
{
|
||||
narray_size_t I;
|
||||
|
||||
printf("{");
|
||||
for(I=0;I<this->length-1;I++)
|
||||
{
|
||||
printf("%ld,",this->data[I]);
|
||||
}
|
||||
if(this->length>=1) printf("%ld",this->data[this->length-1]);
|
||||
printf("}");
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
void test_narray1()
|
||||
{
|
||||
int I;
|
||||
narray<float> a;
|
||||
narray<float> *b = NULL;
|
||||
narray<float> tmp;
|
||||
|
||||
b = new(std::nothrow) narray<float>();
|
||||
a.resize(100);
|
||||
b->resize(100000);
|
||||
a.setall(2.5f);
|
||||
b->setall(3.0f);
|
||||
|
||||
for(I=0;I<100000;I++)
|
||||
{
|
||||
if(b->at(I)!=3.0f)
|
||||
{
|
||||
printf("Error: b[%d]=%1.3f, not %1.3f\n",I,b->at(I),3.0f);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
a.resize(100000);
|
||||
|
||||
tmp = a;
|
||||
a = *b;
|
||||
*b = tmp;
|
||||
|
||||
*b = tmp+a;
|
||||
for(I=0;I<b->length;I++)
|
||||
{
|
||||
if(b->at(I) != tmp[I] + a[I])
|
||||
{
|
||||
printf("addition error in index %d",I);
|
||||
}
|
||||
}
|
||||
|
||||
printf("threaded boolean test: %d\n", (*b==(a+tmp)));
|
||||
|
||||
|
||||
|
||||
delete b;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
void test_narray2()
|
||||
{
|
||||
int I;
|
||||
narray<float> a,b,c,d;
|
||||
|
||||
a.resize(100000); a.setall(1.0f);
|
||||
b.resize(100000); for(I=0;I<b.length;I++) b[I] = 0.5f*I;
|
||||
c.resize(100000); c.setall(2.0f);
|
||||
|
||||
d = -a*(b+c);
|
||||
for(I=0;I<5;I++)
|
||||
{
|
||||
printf("d[%d]=%1.3f\n",I,d[I]);
|
||||
|
||||
}
|
||||
|
||||
printf("d==-a*(b+c):%d\n",d==(-a*(b+c)));
|
||||
d[50000] = 0.0f;
|
||||
printf("d==-a*(b+c):%d\n",d==(-a*(b+c)));
|
||||
|
||||
}
|
||||
|
||||
|
||||
void test_narray3()
|
||||
{
|
||||
int I;
|
||||
narray<float> a,b,c,d;
|
||||
|
||||
a.resize(5); a.setall(1.0f);
|
||||
b = {0,0.25,0.5,0.675,0.8675};
|
||||
c.resize(5); c.setall(2.0f);
|
||||
|
||||
d = -a*(b+c*2+2);
|
||||
for(I=0;I<5;I++)
|
||||
{
|
||||
printf("d[%d]=%1.3f\n",I,d[I]);
|
||||
|
||||
}
|
||||
|
||||
printf("d==-a*(b+c*2+2):%d\n",d==(-a*(b+c*2+2)));
|
||||
d[4] = 0.0f;
|
||||
printf("d==-a*(b+c*2+2):%d\n",d==(-a*(b+c*2+2)));
|
||||
d = d.applyfn(::sinf);
|
||||
|
||||
for(I=0;I<5;I++)
|
||||
{
|
||||
printf("d[%d]=%1.3f\n",I,d[I]);
|
||||
|
||||
}
|
||||
|
||||
d = d.subarray(0,1);
|
||||
for(I=0;I<d.length;I++)
|
||||
{
|
||||
printf("d[%d]=%1.3f\n",I,d[I]);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
void test_insertdelete1()
|
||||
{
|
||||
narray<int> q;
|
||||
int I,J,K;
|
||||
|
||||
q.insert(0,1);
|
||||
q.print(); printf("\n");
|
||||
q.insert(0,2);
|
||||
q.print(); printf("\n");
|
||||
q.insert(0,3);
|
||||
q.print(); printf("\n");
|
||||
q.insert(-1,1);
|
||||
q.print(); printf("\n");
|
||||
q.insert(10,99);
|
||||
q.print(); printf("\n");
|
||||
|
||||
I = 3;
|
||||
printf("q.find(%d)=%d\n",I,(int)q.find(I));
|
||||
I = 1;
|
||||
printf("q.find(%d)=%d\n",I,(int)q.find(I));
|
||||
I = 5;
|
||||
printf("q.find(%d)=%d\n",I,(int)q.find(I));
|
||||
I = 99;
|
||||
printf("q.find(%d)=%d\n",I,(int)q.find(I));
|
||||
|
||||
I = 1;
|
||||
printf("q.findinsert(%d)=%d\n",I,(int)q.find_insert_ordered(I));
|
||||
I = -1;
|
||||
printf("q.findinsert(%d)=%d\n",I,(int)q.find_insert_ordered(I));
|
||||
I = 5;
|
||||
printf("q.findinsert(%d)=%d\n",I,(int)q.find_insert_ordered(I));
|
||||
I = 99;
|
||||
printf("q.findinsert(%d)=%d\n",I,(int)q.find_insert_ordered(I));
|
||||
I = 100;
|
||||
printf("q.findinsert(%d)=%d\n",I,(int)q.find_insert_ordered(I));
|
||||
|
||||
q.erase(0);
|
||||
q.print(); printf("\n");
|
||||
q.erase(-1);
|
||||
q.print(); printf("\n");
|
||||
q.erase(q.length);
|
||||
q.print(); printf("\n");
|
||||
q.erase(q.length-1);
|
||||
q.print(); printf("\n");
|
||||
|
||||
q.resize(0);
|
||||
for(I=0;I<25;I++)
|
||||
{
|
||||
J = rand::dpr32_randint(5,25);
|
||||
K = q.find_insert_ordered(J);
|
||||
q.insert(K,J);
|
||||
q.print(); printf("\n");
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
}; //end namespace narray
|
||||
}; //end namespace ams
|
||||
@@ -0,0 +1,173 @@
|
||||
#include <amscppnarray/amscppnarray.hpp>
|
||||
|
||||
namespace ams
|
||||
{
|
||||
namespace narray
|
||||
{
|
||||
|
||||
void narray_linspacef_tf(
|
||||
narray<float> *in,
|
||||
const float low, const float high, const narray_size_t N,
|
||||
int threadnum, int nthreads
|
||||
)
|
||||
{
|
||||
int I0,I1,Is,I;
|
||||
float g;
|
||||
|
||||
Is = in->length/nthreads;
|
||||
I0 = Is*threadnum;
|
||||
I1 = (threadnum>=(nthreads-1))? in->length: Is*(threadnum+1);
|
||||
for(I=I0;I<I1;I++)
|
||||
{
|
||||
g = ((float)I)/((float)(N-1));
|
||||
in->data[I] = low*(1.0f-g) + high*g;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
narray<float> linspacef(const float low, const float high, narray_size_t N)
|
||||
{
|
||||
narray<float> ret;
|
||||
narray_size_t I;
|
||||
int J;
|
||||
int nthreads;
|
||||
std::vector<std::thread*> threads;
|
||||
float g;
|
||||
|
||||
if(N<=0)
|
||||
{
|
||||
N = 0;
|
||||
}
|
||||
ret.resize(N);
|
||||
|
||||
if(ret.length==0)
|
||||
{
|
||||
return ret;
|
||||
}
|
||||
|
||||
if(ret.length<narray_thread_sz)
|
||||
{
|
||||
for(I=0;I<ret.length;I++)
|
||||
{
|
||||
g = ((float)I)/((float)(N-1));
|
||||
ret.data[I] = low*(1.0f-g) + high*g;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//threaded operation
|
||||
nthreads = std::thread::hardware_concurrency();
|
||||
nthreads = (nthreads<1) ? 1 : nthreads;
|
||||
nthreads = (nthreads>narray_max_threads) ? narray_max_threads : nthreads;
|
||||
//if(nthreads<1) nthreads=1;
|
||||
//if(nthreads>narray_max_threads) nthreads = narray_max_threads;
|
||||
threads.resize(nthreads);
|
||||
for(J=0;J<nthreads;J++)
|
||||
{
|
||||
threads[J] = new(std::nothrow) std::thread(
|
||||
&narray_linspacef_tf,
|
||||
&ret,
|
||||
low,high,N,
|
||||
J,nthreads
|
||||
);
|
||||
}
|
||||
for(J=0;J<nthreads;J++)
|
||||
{
|
||||
if(threads[J]!=NULL)
|
||||
{
|
||||
threads[J]->join();
|
||||
delete threads[J];
|
||||
threads[J]= NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
void narray_linspace_tf(
|
||||
narray<double> *in,
|
||||
const double low, const double high, const narray_size_t N,
|
||||
int threadnum, int nthreads
|
||||
)
|
||||
{
|
||||
int I0,I1,Is,I;
|
||||
double g;
|
||||
|
||||
Is = in->length/nthreads;
|
||||
I0 = Is*threadnum;
|
||||
I1 = (threadnum>=(nthreads-1))? in->length: Is*(threadnum+1);
|
||||
for(I=I0;I<I1;I++)
|
||||
{
|
||||
g = ((double)I)/((double)(N-1));
|
||||
in->data[I] = low*(1.0-g) + high*g;
|
||||
}
|
||||
}
|
||||
|
||||
narray<double> linspace(const double low, const double high, narray_size_t N)
|
||||
{
|
||||
narray<double> ret;
|
||||
narray_size_t I;
|
||||
int J;
|
||||
int nthreads;
|
||||
std::vector<std::thread*> threads;
|
||||
double g;
|
||||
|
||||
if(N<=0)
|
||||
{
|
||||
N = 0;
|
||||
}
|
||||
ret.resize(N);
|
||||
|
||||
if(ret.length==0)
|
||||
{
|
||||
return ret;
|
||||
}
|
||||
|
||||
if(ret.length<narray_thread_sz)
|
||||
{
|
||||
for(I=0;I<ret.length;I++)
|
||||
{
|
||||
g = ((double)I)/((double)(N-1));
|
||||
ret.data[I] = low*(1.0-g) + high*g;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//threaded operation
|
||||
nthreads = std::thread::hardware_concurrency();
|
||||
nthreads = (nthreads<1) ? 1 : nthreads;
|
||||
nthreads = (nthreads>narray_max_threads) ? narray_max_threads : nthreads;
|
||||
//if(nthreads<1) nthreads=1;
|
||||
//if(nthreads>narray_max_threads) nthreads = narray_max_threads;
|
||||
threads.resize(nthreads);
|
||||
for(J=0;J<nthreads;J++)
|
||||
{
|
||||
threads[J] = new(std::nothrow) std::thread(
|
||||
&narray_linspace_tf,
|
||||
&ret,
|
||||
low,high,N,
|
||||
J,nthreads
|
||||
);
|
||||
}
|
||||
for(J=0;J<nthreads;J++)
|
||||
{
|
||||
if(threads[J]!=NULL)
|
||||
{
|
||||
threads[J]->join();
|
||||
delete threads[J];
|
||||
threads[J]= NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
}; //end namespaces
|
||||
};
|
||||
@@ -0,0 +1,110 @@
|
||||
#include <amscppnarray/amscppnarray.hpp>
|
||||
|
||||
namespace ams
|
||||
{
|
||||
namespace narray
|
||||
{
|
||||
|
||||
static void _intl_printarr(narray<int> &q)
|
||||
{
|
||||
int I;
|
||||
if(q.length>0)
|
||||
{
|
||||
printf("{");
|
||||
for(I=0;I<q.length-1;I++) printf("%d,",q[I]);
|
||||
printf("%d}",q[q.length-1]);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("{}");
|
||||
}
|
||||
}
|
||||
|
||||
static void _intl_printarr(narray<double> &q)
|
||||
{
|
||||
int I;
|
||||
if(q.length>0)
|
||||
{
|
||||
printf("{");
|
||||
for(I=0;I<q.length-1;I++) printf("%1.3f,",q[I]);
|
||||
printf("%1.3f}",q[q.length-1]);
|
||||
}
|
||||
else
|
||||
{
|
||||
printf("{}");
|
||||
}
|
||||
}
|
||||
|
||||
void narray_testmath1()
|
||||
{
|
||||
narray<int> a = {-4,-3,-2,-1,0,1,2,3,4,5};
|
||||
narray<int> b;
|
||||
int asum = narray_sum(a);
|
||||
double amean = narray_mean(a);
|
||||
|
||||
printf("sum(a)=%d\n",asum);
|
||||
printf("mean(a)=%1.3f\n",amean);
|
||||
printf("stdev(a)=%1.3f\n",narray_stdev(a));
|
||||
printf("L2norm(a)=%1.3f\n",narray_L2norm(a));
|
||||
printf("min(a)=%d\n",narray_min(a));
|
||||
printf("max(a)=%d\n",narray_max(a));
|
||||
|
||||
b = narray_abs(a);
|
||||
_intl_printarr(b); printf("\n");
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
void narray_testmath2()
|
||||
{
|
||||
//rand::narray_rands_t rs = 1943981;
|
||||
rand::set_rseed_withtimer();
|
||||
printf("rseed: %d\n",(int)rand::get_rseed());
|
||||
printf("rseed: %d\n",(int)rand::dpr32_rseed); //< -- this is different than the line above
|
||||
|
||||
|
||||
narray<double> unif = ams::narray::rand::narray_rand(10000*10000);
|
||||
|
||||
|
||||
printf("rseed: %d\n",(int)rand::get_rseed());
|
||||
|
||||
double mn1 = narray_mean(unif);
|
||||
double std1 = narray_stdev(unif);
|
||||
double mn2,std2;
|
||||
|
||||
|
||||
|
||||
//_intl_printarr(unif); printf("\n");
|
||||
|
||||
unif = unif*2.0-1.0;
|
||||
//unif.setall(3.5);
|
||||
//_intl_printarr(unif); printf("\n");
|
||||
mn2 = narray_mean(unif);
|
||||
std2 = narray_stdev(unif);
|
||||
|
||||
|
||||
|
||||
|
||||
printf("mn1=%1.3f std1=%1.3f\n",mn1,std1);
|
||||
printf("mn2=%1.3f std2=%1.3f\n",mn2,std2);
|
||||
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
void narray_testmath3()
|
||||
{
|
||||
narray<double> rb;
|
||||
const char *fout = "./tmp_testrand.bin";
|
||||
FILE *fp = NULL;
|
||||
fp = fopen(fout,"w+b");
|
||||
|
||||
rb = rand::narray_rand(500*500);
|
||||
fwrite_ndarray<double>(fp,&rb,NULL);
|
||||
|
||||
fclose(fp);
|
||||
|
||||
}
|
||||
|
||||
};
|
||||
};
|
||||
@@ -0,0 +1,592 @@
|
||||
#include <amscppnarray/amscppnarray.hpp>
|
||||
|
||||
namespace ams
|
||||
{
|
||||
namespace narray
|
||||
{
|
||||
namespace rand
|
||||
{
|
||||
|
||||
//defining global random number seed for numeric array random routines
|
||||
narray_rands_t dpr32_rseed = 0;
|
||||
|
||||
narray_rands_t dpr32_nextseed(narray_rands_t seed)
|
||||
{
|
||||
narray_rands_t sret = seed;
|
||||
sret = ams::mod(sret*dpr32_mult1+dpr32_add1,dpr32_mod);
|
||||
return sret;
|
||||
}
|
||||
|
||||
double dpr32_randd(narray_rands_t *seed)
|
||||
{
|
||||
double ret;
|
||||
//printf("debug: seed: %d\n",(int)*seed);
|
||||
*seed = ams::narray::rand::dpr32_nextseed(*seed);
|
||||
//printf("debug: seed: %d\n",(int)*seed);
|
||||
ret = (double)*seed/(double)(dpr32_mod-1);
|
||||
return ret;
|
||||
}
|
||||
|
||||
float dpr32_randf(narray_rands_t *seed)
|
||||
{
|
||||
float ret;
|
||||
*seed = ams::narray::rand::dpr32_nextseed(*seed);
|
||||
ret = (float)*seed/(float)(dpr32_mod-1);
|
||||
return ret;
|
||||
}
|
||||
|
||||
double dpr32_gaussian(narray_rands_t *seed)
|
||||
{
|
||||
double ret = 0.0;
|
||||
double u1,u2;
|
||||
u1 = ams::narray::rand::dpr32_randd(seed);
|
||||
u2 = ams::narray::rand::dpr32_randd(seed);
|
||||
|
||||
if(u1>0.0)
|
||||
{
|
||||
ret = ::sqrt(-2.0*::log(u1))*::cos(2.0*pi*u2);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
float dpr32_gaussianf(narray_rands_t *seed)
|
||||
{
|
||||
float ret = 0.0f;
|
||||
float u1,u2;
|
||||
u1 = ams::narray::rand::dpr32_randf(seed);
|
||||
u2 = ams::narray::rand::dpr32_randf(seed);
|
||||
|
||||
if(u1>0.0)
|
||||
{
|
||||
ret = ::sqrt(-2.0f*::log(u1))*::cos(2.0f*pif*u2);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
vec2 dpr32_randuvec2(narray_rands_t *seed)
|
||||
{
|
||||
vec2 ret = vec2(0,0);
|
||||
double th = ams::narray::rand::dpr32_randd(seed)*2.0*pi;
|
||||
ret = vec2(cos(th),sin(th));
|
||||
return ret;
|
||||
}
|
||||
|
||||
vec3 dpr32_randuvec3(narray_rands_t *seed)
|
||||
{
|
||||
vec3 ret;
|
||||
double az,el;
|
||||
el = ::acos(2.0*dpr32_randd(seed)-1.0)-pi/2.0;
|
||||
az = ams::narray::rand::dpr32_randd(seed)*2.0*pi;
|
||||
|
||||
ret = vec3(cos(az)*cos(el),sin(az)*cos(el),sin(el));
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
vec4 dpr32_randuvec4(narray_rands_t *seed)
|
||||
{
|
||||
vec4 ret;
|
||||
double x,y,z,w;
|
||||
|
||||
x = ams::narray::rand::dpr32_gaussian(seed);
|
||||
y = ams::narray::rand::dpr32_gaussian(seed);
|
||||
z = ams::narray::rand::dpr32_gaussian(seed);
|
||||
w = ams::narray::rand::dpr32_gaussian(seed);
|
||||
ret = vec4(x,y,z,w);
|
||||
ret = vnormalize(ret);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
vec2f dpr32_randuvec2f(narray_rands_t *seed)
|
||||
{
|
||||
vec2f ret = vec2f(0,0);
|
||||
float th = ams::narray::rand::dpr32_randf(seed)*2.0*pi;
|
||||
ret = vec2f(cos(th),sin(th));
|
||||
return ret;
|
||||
}
|
||||
|
||||
vec3f dpr32_randuvec3f(narray_rands_t *seed)
|
||||
{
|
||||
vec3f ret;
|
||||
float az,el;
|
||||
el = ::acos(2.0f*dpr32_randf(seed)-1.0)-pif/2.0;
|
||||
az = ams::narray::rand::dpr32_randf(seed)*2.0f*pif;
|
||||
|
||||
ret = vec3f(cos(az)*cos(el),sin(az)*cos(el),sin(el));
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
vec4f dpr32_randuvec4f(narray_rands_t *seed)
|
||||
{
|
||||
vec4f ret;
|
||||
float x,y,z,w;
|
||||
|
||||
x = ams::narray::rand::dpr32_gaussianf(seed);
|
||||
y = ams::narray::rand::dpr32_gaussianf(seed);
|
||||
z = ams::narray::rand::dpr32_gaussianf(seed);
|
||||
w = ams::narray::rand::dpr32_gaussianf(seed);
|
||||
ret = vec4f(x,y,z,w);
|
||||
ret = vnormalize(ret);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
narray_rands_t get_rseed()
|
||||
{
|
||||
return ams::narray::rand::dpr32_rseed;
|
||||
}
|
||||
|
||||
void set_rseed(narray_rands_t seed)
|
||||
{
|
||||
ams::narray::rand::dpr32_rseed = seed;
|
||||
}
|
||||
|
||||
void set_rseed_withtimer()
|
||||
{
|
||||
narray_rands_t t1 = (narray_rands_t)time(NULL);
|
||||
narray_rands_t t2 = (narray_rands_t)(::fmod((double)clock()/((double)CLOCKS_PER_SEC)*1000.0f,36000.0f));
|
||||
ams::narray::rand::dpr32_rseed = (narray_rands_t)t1 + (narray_rands_t)t2;
|
||||
}
|
||||
|
||||
template<typename T> void narray_rand_threadf1(
|
||||
narray<T> *out,
|
||||
narray<narray_rands_t> *rseeds,
|
||||
T (*randfunc)(narray_rands_t *),
|
||||
int threadnum,
|
||||
int nthreads
|
||||
)
|
||||
{
|
||||
int I0,I1,Is,I;
|
||||
Is = out->length/nthreads;
|
||||
I0 = Is*threadnum;
|
||||
I1 = (threadnum>=(nthreads-1)) ? out->length : Is*(threadnum+1);
|
||||
for(I=I0;I<I1;I++)
|
||||
{
|
||||
out->data[I] = randfunc(&(rseeds->data[threadnum]));
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
template<typename T> void narray_random_threadexec1(
|
||||
narray<T> *out,
|
||||
narray_size_t N,
|
||||
T (*randfunc)(narray_rands_t *),
|
||||
narray_rands_t *rseed
|
||||
)
|
||||
{
|
||||
narray_size_t I;
|
||||
int J;
|
||||
int nthreads;
|
||||
std::vector<std::thread*> threads;
|
||||
narray<narray_rands_t> rseeds;
|
||||
int res;
|
||||
|
||||
res = out->resize(N);
|
||||
if(res!=narray_success)
|
||||
{
|
||||
out->resize(0);
|
||||
return;
|
||||
}
|
||||
|
||||
if(N<narray_thread_sz)
|
||||
{
|
||||
//single threaded
|
||||
for(I=0;I<N;I++)
|
||||
{
|
||||
out->data[I] = randfunc(rseed);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//multi-threaded operation
|
||||
nthreads = std::thread::hardware_concurrency();
|
||||
nthreads = (nthreads<1) ? 1 : nthreads;
|
||||
nthreads = (nthreads>narray_max_threads) ? narray_max_threads : nthreads;
|
||||
threads.resize(nthreads);
|
||||
rseeds.resize(nthreads);
|
||||
|
||||
for(J=0;J<nthreads;J++)
|
||||
{
|
||||
*rseed = dpr32_nextseed(*rseed);
|
||||
rseeds.data[J] = *rseed + 13*J;
|
||||
}
|
||||
for(J=0;J<nthreads;J++)
|
||||
{
|
||||
threads[J] = new(std::nothrow) std::thread(
|
||||
&narray_rand_threadf1<T>,
|
||||
out,
|
||||
&rseeds,
|
||||
randfunc,
|
||||
J,nthreads
|
||||
);
|
||||
if(threads[J]==NULL)
|
||||
{
|
||||
//handle thread allocation error
|
||||
printf("warning: narray_random_threadexec1:: thread %d failed to allocate.\n",J);
|
||||
}
|
||||
}
|
||||
for(J=0;J<nthreads;J++)
|
||||
{
|
||||
if(threads[J]!=NULL)
|
||||
{
|
||||
threads[J]->join();
|
||||
delete threads[J];
|
||||
threads[J]= NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
narray<double> narray_rand(narray_size_t N,
|
||||
narray_rands_t *rseed)
|
||||
{
|
||||
narray<double> ret;
|
||||
|
||||
if(N<=0)
|
||||
{
|
||||
ret.resize(0);
|
||||
return ret;
|
||||
}
|
||||
|
||||
narray_random_threadexec1(
|
||||
&ret,
|
||||
N,
|
||||
&(ams::narray::rand::dpr32_randd),
|
||||
rseed
|
||||
);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
narray<float> narray_randf(narray_size_t N,
|
||||
narray_rands_t *rseed)
|
||||
{
|
||||
narray<float> ret;
|
||||
|
||||
if(N<=0)
|
||||
{
|
||||
ret.resize(0);
|
||||
return ret;
|
||||
}
|
||||
|
||||
narray_random_threadexec1(
|
||||
&ret,
|
||||
N,
|
||||
&(ams::narray::rand::dpr32_randf),
|
||||
rseed
|
||||
);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
narray<double> narray_randgauss(narray_size_t N,
|
||||
narray_rands_t *rseed)
|
||||
{
|
||||
narray<double> ret;
|
||||
|
||||
if(N<=0)
|
||||
{
|
||||
ret.resize(0);
|
||||
return ret;
|
||||
}
|
||||
|
||||
narray_random_threadexec1(
|
||||
&ret,
|
||||
N,
|
||||
&(ams::narray::rand::dpr32_gaussian),
|
||||
rseed
|
||||
);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
narray<float> narray_randgaussf(narray_size_t N,
|
||||
narray_rands_t *rseed)
|
||||
{
|
||||
narray<float> ret;
|
||||
|
||||
if(N<=0)
|
||||
{
|
||||
ret.resize(0);
|
||||
return ret;
|
||||
}
|
||||
|
||||
narray_random_threadexec1(
|
||||
&ret,
|
||||
N,
|
||||
&(ams::narray::rand::dpr32_gaussianf),
|
||||
rseed
|
||||
);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
narray<vec2> narray_randuvec2(narray_size_t N,
|
||||
narray_rands_t *rseed)
|
||||
{
|
||||
narray<vec2> ret;
|
||||
|
||||
if(N<=0)
|
||||
{
|
||||
ret.resize(0);
|
||||
return ret;
|
||||
}
|
||||
|
||||
narray_random_threadexec1(
|
||||
&ret,
|
||||
N,
|
||||
&(ams::narray::rand::dpr32_randuvec2),
|
||||
rseed
|
||||
);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
narray<vec3> narray_randuvec3(narray_size_t N,
|
||||
narray_rands_t *rseed)
|
||||
{
|
||||
narray<vec3> ret;
|
||||
|
||||
if(N<=0)
|
||||
{
|
||||
ret.resize(0);
|
||||
return ret;
|
||||
}
|
||||
|
||||
narray_random_threadexec1(
|
||||
&ret,
|
||||
N,
|
||||
&(ams::narray::rand::dpr32_randuvec3),
|
||||
rseed
|
||||
);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
narray<vec4> narray_randuvec4(narray_size_t N,
|
||||
narray_rands_t *rseed)
|
||||
{
|
||||
narray<vec4> ret;
|
||||
|
||||
if(N<=0)
|
||||
{
|
||||
ret.resize(0);
|
||||
return ret;
|
||||
}
|
||||
|
||||
narray_random_threadexec1(
|
||||
&ret,
|
||||
N,
|
||||
&(ams::narray::rand::dpr32_randuvec4),
|
||||
rseed
|
||||
);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
narray<vec2f> narray_randuvec2f(narray_size_t N,
|
||||
narray_rands_t *rseed)
|
||||
{
|
||||
narray<vec2f> ret;
|
||||
|
||||
if(N<=0)
|
||||
{
|
||||
ret.resize(0);
|
||||
return ret;
|
||||
}
|
||||
|
||||
narray_random_threadexec1(
|
||||
&ret,
|
||||
N,
|
||||
&(ams::narray::rand::dpr32_randuvec2f),
|
||||
rseed
|
||||
);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
narray<vec3f> narray_randuvec3f(narray_size_t N,
|
||||
narray_rands_t *rseed)
|
||||
{
|
||||
narray<vec3f> ret;
|
||||
|
||||
if(N<=0)
|
||||
{
|
||||
ret.resize(0);
|
||||
return ret;
|
||||
}
|
||||
|
||||
narray_random_threadexec1(
|
||||
&ret,
|
||||
N,
|
||||
&(ams::narray::rand::dpr32_randuvec3f),
|
||||
rseed
|
||||
);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
narray<vec4f> narray_randuvec4f(narray_size_t N,
|
||||
narray_rands_t *rseed)
|
||||
{
|
||||
narray<vec4f> ret;
|
||||
|
||||
if(N<=0)
|
||||
{
|
||||
ret.resize(0);
|
||||
return ret;
|
||||
}
|
||||
|
||||
narray_random_threadexec1(
|
||||
&ret,
|
||||
N,
|
||||
&(ams::narray::rand::dpr32_randuvec4f),
|
||||
rseed
|
||||
);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
int dpr32_randint(int low, int high, narray_rands_t *seed)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
|
||||
if(high-low>0)
|
||||
{
|
||||
*seed = dpr32_nextseed(*seed);
|
||||
ret = low + (int)((*seed)%(high-low));
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
template<typename T> void narray_rand_threadf2(
|
||||
narray<T> *out,
|
||||
narray<narray_rands_t> *rseeds,
|
||||
T (*randfunc)(T, T, narray_rands_t*),
|
||||
T low,
|
||||
T highexcl,
|
||||
int threadnum,
|
||||
int nthreads
|
||||
)
|
||||
{
|
||||
int I0,I1,Is,I;
|
||||
Is = out->length/nthreads;
|
||||
I0 = Is*threadnum;
|
||||
I1 = (threadnum>=(nthreads-1)) ? out->length : Is*(threadnum+1);
|
||||
for(I=I0;I<I1;I++)
|
||||
{
|
||||
out->data[I] = randfunc(low,highexcl,&(rseeds->data[threadnum]));
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
template<typename T> void narray_random_threadexec2(
|
||||
narray<T> *out,
|
||||
narray_size_t N,
|
||||
T (*randfunc)(T, T, narray_rands_t *),
|
||||
T low,
|
||||
T highexcl,
|
||||
narray_rands_t *rseed
|
||||
)
|
||||
{
|
||||
narray_size_t I;
|
||||
int J;
|
||||
int nthreads;
|
||||
std::vector<std::thread*> threads;
|
||||
narray<narray_rands_t> rseeds;
|
||||
int res;
|
||||
|
||||
res = out->resize(N);
|
||||
if(res!=narray_success)
|
||||
{
|
||||
out->resize(0);
|
||||
return;
|
||||
}
|
||||
|
||||
if(N<narray_thread_sz)
|
||||
{
|
||||
//single threaded
|
||||
for(I=0;I<N;I++)
|
||||
{
|
||||
out->data[I] = randfunc(low,highexcl,rseed);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//multi-threaded operation
|
||||
nthreads = std::thread::hardware_concurrency();
|
||||
nthreads = (nthreads<1) ? 1 : nthreads;
|
||||
nthreads = (nthreads>narray_max_threads) ? narray_max_threads : nthreads;
|
||||
threads.resize(nthreads);
|
||||
rseeds.resize(nthreads);
|
||||
for(J=0;J<nthreads;J++)
|
||||
{
|
||||
*rseed = dpr32_nextseed(*rseed);
|
||||
rseeds.data[J] = *rseed + 13*J;
|
||||
}
|
||||
for(J=0;J<nthreads;J++)
|
||||
{
|
||||
threads[J] = new(std::nothrow) std::thread(
|
||||
&narray_rand_threadf2<T>,
|
||||
out,
|
||||
&rseeds,
|
||||
randfunc,
|
||||
low,highexcl,
|
||||
J,nthreads
|
||||
);
|
||||
if(threads[J]==NULL)
|
||||
{
|
||||
//handle thread allocation error
|
||||
printf("warning: narray_random_threadexec1:: thread %d failed to allocate.\n",J);
|
||||
}
|
||||
}
|
||||
for(J=0;J<nthreads;J++)
|
||||
{
|
||||
if(threads[J]!=NULL)
|
||||
{
|
||||
threads[J]->join();
|
||||
delete threads[J];
|
||||
threads[J]= NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
narray<int> narray_randint(narray_size_t N, int low, int highexcl,
|
||||
narray_rands_t *rseed)
|
||||
{
|
||||
narray<int> ret;
|
||||
|
||||
if(N<=0)
|
||||
{
|
||||
ret.resize(0);
|
||||
return ret;
|
||||
}
|
||||
|
||||
narray_random_threadexec2(
|
||||
&ret,
|
||||
N,
|
||||
&(ams::narray::rand::dpr32_randint),
|
||||
low,highexcl,
|
||||
rseed
|
||||
);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
}; //end namespace rand
|
||||
}; //end namespaces
|
||||
};
|
||||
@@ -0,0 +1,16 @@
|
||||
#include <amscppnarray/amscppnarray.hpp>
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
int ret = 0;
|
||||
printf("ams c++ numeric array library tests.\n");
|
||||
ams::narray::test_narray1();
|
||||
ams::narray::test_narray2();
|
||||
ams::narray::test_narray3();
|
||||
ams::narray::narray_testmath1();
|
||||
ams::narray::narray_testmath2();
|
||||
ams::narray::narray_testmath3();
|
||||
ams::narray::test_insertdelete1();
|
||||
|
||||
return ret;
|
||||
}
|
||||
Reference in new issue
Block a user