This commit is contained in:
madrocketsci committed 2025-06-22 16:48:23 -04:00
commit cad98f8211
64 files changed
+5157

No files matched your search

+230
View File
@@ -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
+173
View File
@@ -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
};
+110
View File
@@ -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);
}
};
};
+592
View File
@@ -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
};
+16
View File
@@ -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;
}