Index: trunk/psLib/test/math/tap_psMinimizeLMM.c
===================================================================
--- trunk/psLib/test/math/tap_psMinimizeLMM.c	(revision 22714)
+++ trunk/psLib/test/math/tap_psMinimizeLMM.c	(revision 23259)
@@ -95,5 +95,5 @@
     {
         psMemId id = psMemGetId();
-        psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
+        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
         psMinimization *min = psMinimizationAlloc(NUM_ITERATIONS, ERR_TOL);
         psArray *ordinates = psArrayAlloc(NUM_DATA_POINTS);
@@ -203,5 +203,5 @@
     {
         psMemId id = psMemGetId();
-        psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
+        psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
         psMinimization *min = psMinimizationAlloc(NUM_ITERATIONS, ERR_TOL);
         psArray *ordinates = psArrayAlloc(NUM_DATA_POINTS);
Index: trunk/psLib/test/math/tap_psPolyFit1D.c
===================================================================
--- trunk/psLib/test/math/tap_psPolyFit1D.c	(revision 22714)
+++ trunk/psLib/test/math/tap_psPolyFit1D.c	(revision 23259)
@@ -109,5 +109,5 @@
     psVector *xTruth = psVectorAlloc(numData, PS_TYPE_F64);
     psVector *fTruth = psVectorAlloc(numData, PS_TYPE_F64);
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using a known seed
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using a known seed
     for (int i = 0; i < numData; i++) {
         xTruth->data.F64[i] = (flags & TS00_X_NULL) ? i : 2.0*psRandomUniform(rng) - 1.0;
Index: trunk/psLib/test/math/tap_psPolyFit2D.c
===================================================================
--- trunk/psLib/test/math/tap_psPolyFit2D.c	(revision 22714)
+++ trunk/psLib/test/math/tap_psPolyFit2D.c	(revision 23259)
@@ -108,5 +108,5 @@
     yTruth->n = numData;
     fTruth->n = numData;
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using an RNG with a known seed
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using an RNG with a known seed
     for (int i = 0; i < numData; i++) {
         xTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;
Index: trunk/psLib/test/math/tap_psPolyFit3D.c
===================================================================
--- trunk/psLib/test/math/tap_psPolyFit3D.c	(revision 22714)
+++ trunk/psLib/test/math/tap_psPolyFit3D.c	(revision 23259)
@@ -108,5 +108,5 @@
     zTruth->n = numData;
     fTruth->n = numData;
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using known seed
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using known seed
     for (int i = 0; i < numData; i++) {
         xTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;
Index: trunk/psLib/test/math/tap_psPolyFit4D.c
===================================================================
--- trunk/psLib/test/math/tap_psPolyFit4D.c	(revision 22714)
+++ trunk/psLib/test/math/tap_psPolyFit4D.c	(revision 23259)
@@ -132,5 +132,5 @@
     tTruth->n = numData;
     fTruth->n = numData;
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using known seed
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using known seed
     for (int i = 0; i < numData; i++) {
         xTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;
Index: trunk/psLib/test/math/tap_psRandom.c
===================================================================
--- trunk/psLib/test/math/tap_psRandom.c	(revision 22714)
+++ trunk/psLib/test/math/tap_psRandom.c	(revision 23259)
@@ -3,5 +3,5 @@
 work properly.
  
-    ensure that psRandom structs are properly allocated by psRandomAlloc().
+    ensure that psRandom structs are properly allocated by psRandomAllocSpecific().
     ensure that psRandomUniform() produces a sequence of numbers with
         proper mean and stdev.
@@ -47,12 +47,12 @@
     plan_tests(34);
 
-    // ensure that psRandom structs are properly allocated by psRandomAlloc()
+    // ensure that psRandom structs are properly allocated by psRandomAllocSpecific()
     {
         psMemId id = psMemGetId();
         // Valid type allocation
-        psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
-        ok(myRNG != NULL, "psRandom struct was allocated properly");
-        skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAlloc() failed");
-        ok(myRNG->type == PS_RANDOM_TAUS, "psRandomAlloc() set type properly");
+        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
+        ok(myRNG != NULL, "psRandom struct was allocated properly");
+        skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAllocSpecific() failed");
+        ok(myRNG->type == PS_RANDOM_TAUS, "psRandomAllocSpecific() set type properly");
         psFree(myRNG);
         skip_end();
@@ -63,6 +63,6 @@
     {
         psMemId id = psMemGetId();
-        psRandom *myRNG = psRandomAlloc(100,SEED);
-        ok(myRNG == NULL, "psRandomAlloc() refused to generate psRandom with unallowed type");
+        psRandom *myRNG = psRandomAllocSpecific(100,SEED);
+        ok(myRNG == NULL, "psRandomAllocSpecific() refused to generate psRandom with unallowed type");
         psFree(myRNG);
         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
@@ -72,6 +72,6 @@
     {
         psMemId id = psMemGetId();
-        psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS,-5);
-        ok(myRNG != NULL, "psRandomAlloc() allows negative seed");
+        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS,-5);
+        ok(myRNG != NULL, "psRandomAllocSpecific() allows negative seed");
         psFree(myRNG);
         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
@@ -85,7 +85,7 @@
         rans->n = rans->nalloc;
         psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
-        psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
-        ok(myRNG != NULL, "psRandom struct was allocated properly");
-        skip_start(myRNG == NULL, 2, "Skipping tests because psRandomAlloc() failed");
+        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
+        ok(myRNG != NULL, "psRandom struct was allocated properly");
+        skip_start(myRNG == NULL, 2, "Skipping tests because psRandomAllocSpecific() failed");
 
         // Initialize vector data with random number
@@ -125,7 +125,7 @@
         rans->n = rans->nalloc;
         psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
-        psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
-        ok(myRNG != NULL, "psRandom struct was allocated properly");
-        skip_start(myRNG == NULL, 2, "Skipping tests because psRandomAlloc() failed");
+        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
+        ok(myRNG != NULL, "psRandom struct was allocated properly");
+        skip_start(myRNG == NULL, 2, "Skipping tests because psRandomAllocSpecific() failed");
 
         // Initialize vector with random data
@@ -167,7 +167,7 @@
         rans->n = rans->nalloc;
         psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
-        psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
-        ok(myRNG != NULL, "psRandom struct was allocated properly");
-        skip_start(myRNG == NULL, 2, "Skipping tests because psRandomAlloc() failed");
+        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
+        ok(myRNG != NULL, "psRandom struct was allocated properly");
+        skip_start(myRNG == NULL, 2, "Skipping tests because psRandomAllocSpecific() failed");
 
         // Initialize vector with random data
@@ -210,7 +210,7 @@
         rans02->n = rans02->nalloc;
 
-        psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
-        ok(myRNG != NULL, "psRandom struct was allocated properly");
-        skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAlloc() failed");
+        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
+        ok(myRNG != NULL, "psRandom struct was allocated properly");
+        skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAllocSpecific() failed");
 
 
@@ -252,5 +252,5 @@
     if (0) {
         psRandom *myRNG1 = NULL;
-        myRNG1 = psRandomAlloc(PS_RANDOM_TAUS, SEED);
+        myRNG1 = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
         //    psLogSetDestination("dest:stderr");
         psLogSetDestination(0);
@@ -275,7 +275,7 @@
         rans02->n = rans02->nalloc;
 
-        psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
-        ok(myRNG != NULL, "psRandom struct was allocated properly");
-        skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAlloc() failed");
+        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
+        ok(myRNG != NULL, "psRandom struct was allocated properly");
+        skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAllocSpecific() failed");
 
 
@@ -325,7 +325,7 @@
         rans02->n = rans02->nalloc;
 
-        psRandom *myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
-        ok(myRNG != NULL, "psRandom struct was allocated properly");
-        skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAlloc() failed");
+        psRandom *myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
+        ok(myRNG != NULL, "psRandom struct was allocated properly");
+        skip_start(myRNG == NULL, 1, "Skipping tests because psRandomAllocSpecific() failed");
 
         // Initialize vectors with random data
Index: trunk/psLib/test/math/tap_psStats07.c
===================================================================
--- trunk/psLib/test/math/tap_psStats07.c	(revision 22714)
+++ trunk/psLib/test/math/tap_psStats07.c	(revision 23259)
@@ -58,6 +58,6 @@
     PS_ASSERT_INT_NONNEGATIVE(Npts, NULL);
 
-    //    psRandom *r = psRandomAlloc(PS_RANDOM_TAUS, p_psRandomGetSystemSeed());
-    psRandom *r = psRandomAlloc(PS_RANDOM_TAUS, PS_XXX_GAUSSIAN_SEED);
+    //    psRandom *r = psRandomAllocSpecific(PS_RANDOM_TAUS, p_psRandomGetSystemSeed());
+    psRandom *r = psRandomAllocSpecific(PS_RANDOM_TAUS, PS_XXX_GAUSSIAN_SEED);
     psVector* gauss = psVectorAlloc(Npts, PS_TYPE_F32);
     for (unsigned int i = 0; i < Npts; i++) {
Index: trunk/psLib/test/math/tap_psStats09.c
===================================================================
--- trunk/psLib/test/math/tap_psStats09.c	(revision 22714)
+++ trunk/psLib/test/math/tap_psStats09.c	(revision 23259)
@@ -52,5 +52,5 @@
     srand(SEED);
 
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
     psVector *truth = psVectorAlloc(numData, PS_TYPE_F64);
     for (long i = 0; i < numData; i++) {
Index: trunk/psLib/test/math/tap_psStatsTiming.c
===================================================================
--- trunk/psLib/test/math/tap_psStatsTiming.c	(revision 22714)
+++ trunk/psLib/test/math/tap_psStatsTiming.c	(revision 23259)
@@ -20,5 +20,5 @@
 
     // build a gauss-deviate vector (mean = 0.0, sigma = 1.0) for tests
-    psRandom *seed = psRandomAlloc (PS_RANDOM_TAUS, 0);
+    psRandom *seed = psRandomAllocSpecific (PS_RANDOM_TAUS, 0);
     psVector *rnd = psVectorAlloc (1000, PS_TYPE_F32);
     for (int i = 0; i < rnd->n; i++) {
Index: trunk/psLib/test/math/tst_psMinimizeLMM.c
===================================================================
--- trunk/psLib/test/math/tst_psMinimizeLMM.c	(revision 22714)
+++ trunk/psLib/test/math/tst_psMinimizeLMM.c	(revision 23259)
@@ -66,5 +66,5 @@
     psBool testStatus = true;
 
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
     psMinimization *min = psMinimizationAlloc(NUM_ITERATIONS, ERR_TOL);
     psArray *ordinates = psArrayAlloc(NUM_DATA_POINTS);
Index: trunk/psLib/test/math/tst_psPolyFit1D.c
===================================================================
--- trunk/psLib/test/math/tst_psPolyFit1D.c	(revision 22714)
+++ trunk/psLib/test/math/tst_psPolyFit1D.c	(revision 23259)
@@ -101,5 +101,5 @@
     xTruth->n = numData;
     fTruth->n = numData;
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using a known seed
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using a known seed
     for (int i = 0; i < numData; i++) {
         xTruth->data.F64[i] = (flags & TS00_X_NULL) ? i : 2.0*psRandomUniform(rng) - 1.0;
Index: trunk/psLib/test/math/tst_psPolyFit2D.c
===================================================================
--- trunk/psLib/test/math/tst_psPolyFit2D.c	(revision 22714)
+++ trunk/psLib/test/math/tst_psPolyFit2D.c	(revision 23259)
@@ -100,5 +100,5 @@
     yTruth->n = numData;
     fTruth->n = numData;
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using an RNG with a known seed
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using an RNG with a known seed
     for (int i = 0; i < numData; i++) {
         xTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;
Index: trunk/psLib/test/math/tst_psPolyFit3D.c
===================================================================
--- trunk/psLib/test/math/tst_psPolyFit3D.c	(revision 22714)
+++ trunk/psLib/test/math/tst_psPolyFit3D.c	(revision 23259)
@@ -103,5 +103,5 @@
     zTruth->n = numData;
     fTruth->n = numData;
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using known seed
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using known seed
     for (int i = 0; i < numData; i++) {
         xTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;
Index: trunk/psLib/test/math/tst_psPolyFit4D.c
===================================================================
--- trunk/psLib/test/math/tst_psPolyFit4D.c	(revision 22714)
+++ trunk/psLib/test/math/tst_psPolyFit4D.c	(revision 23259)
@@ -124,5 +124,5 @@
     tTruth->n = numData;
     fTruth->n = numData;
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Using known seed
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Using known seed
     for (int i = 0; i < numData; i++) {
         xTruth->data.F64[i] = 2.0*psRandomUniform(rng) - 1.0;
Index: trunk/psLib/test/math/tst_psRandom.c
===================================================================
--- trunk/psLib/test/math/tst_psRandom.c	(revision 22714)
+++ trunk/psLib/test/math/tst_psRandom.c	(revision 23259)
@@ -3,5 +3,5 @@
 work properly.
  
-    t00(): ensure that psRandom structs are properly allocated by psRandomAlloc().
+    t00(): ensure that psRandom structs are properly allocated by psRandomAllocSpecific().
     t01(): ensure that psRandomUniform() produces a sequence of numbers with
     proper mean and stdev.
@@ -45,5 +45,5 @@
 
 testDescription tests[] = {
-                              {testRandomAlloc,000,"psRandomAlloc",0,false},
+                              {testRandomAlloc,000,"psRandomAllocSpecific",0,false},
                               {testRandomUniform,000,"psRandomUniform",0,false},
                               {testRandomGaussian,000,"psRandomGaussian",0,false},
@@ -70,5 +70,5 @@
 
     // Valid type allocation
-    myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
+    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
     if (myRNG == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure");
@@ -85,5 +85,5 @@
     //    psLogSetDestination("file:seed_msglog1.txt");
     psLogSetDestination(fd1);
-    myRNG = psRandomAlloc(PS_RANDOM_TAUS, 0);
+    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, 0);
     //    psLogSetDestination("dest:stderr");
     psLogSetDestination(2);
@@ -100,5 +100,5 @@
     // Invalid type allocation
     psLogMsg(__func__,PS_LOG_INFO,"Invalid type, should generate error message");
-    myRNG = psRandomAlloc(100,SEED);
+    myRNG = psRandomAllocSpecific(100,SEED);
     if (myRNG != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Did not return NULL for invalid type");
@@ -107,5 +107,5 @@
 
     // Negative seed value
-    myRNG = psRandomAlloc(PS_RANDOM_TAUS,-5);
+    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS,-5);
     if(myRNG == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Did not return allocated psRandom");
@@ -125,5 +125,5 @@
     psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
 
-    myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
+    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
     if (myRNG == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure");
@@ -171,5 +171,5 @@
     psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
 
-    myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
+    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
     if (myRNG == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure");
@@ -219,5 +219,5 @@
     psStats *stats = psStatsAlloc(PS_STAT_SAMPLE_MEAN);
 
-    myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
+    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
     if (myRNG == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure");
@@ -268,5 +268,5 @@
     rans02->n = rans02->nalloc;
 
-    myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
+    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
     if (myRNG == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure");
@@ -302,5 +302,5 @@
 
     psRandom *myRNG1 = NULL;
-    myRNG1 = psRandomAlloc(PS_RANDOM_TAUS, SEED);
+    myRNG1 = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
     //    psLogSetDestination("dest:stderr");
     psLogSetDestination(0);
@@ -326,5 +326,5 @@
     rans02->n = rans02->nalloc;
 
-    myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
+    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
     if (myRNG == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure");
@@ -372,5 +372,5 @@
     rans02->n = rans02->nalloc;
 
-    myRNG = psRandomAlloc(PS_RANDOM_TAUS, SEED);
+    myRNG = psRandomAllocSpecific(PS_RANDOM_TAUS, SEED);
     if (myRNG == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Could not allocate psRandom structure");
Index: trunk/psLib/test/math/tst_psStats09.c
===================================================================
--- trunk/psLib/test/math/tst_psStats09.c	(revision 22714)
+++ trunk/psLib/test/math/tst_psStats09.c	(revision 23259)
@@ -52,5 +52,5 @@
     printPositiveTestHeader(stdout, "psMathUtils functions", "psVectorStats Clipped Stats Routine");
 
-    psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
+    psRandom *rng = psRandomAllocSpecific(PS_RANDOM_TAUS, 1); // Random number generator; using known seed
     psVector *truth = psVectorAlloc(numData, PS_TYPE_F64);
     truth->n = numData;