commit 9453d2c5683838d09e41b488bef914ce96941e34
parent 82da6ddf896e0797f14c662482d13c6379e44cc5
Author: Vincent Forest <vincent.forest@meso-star.com>
Date: Wed, 13 Dec 2017 10:16:57 +0100
Merge branch 'release_0.6'
Diffstat:
16 files changed, 704 insertions(+), 505 deletions(-)
diff --git a/README.md b/README.md
@@ -29,14 +29,25 @@ standard on current Microsoft compilers.
For this platform install the Boost random library. Then generate the CMake
project as above, excepted that you need to add the Boost install directory to
-the `CMAKE_PREFIX_PATH` variable and to set the `BOOST_INCLUDEDIR` cmake
+the `CMAKE_PREFIX_PATH` variable and to set the `BOOST_INCLUDEDIR` cmake
variable to the directory that contains the `boost` include directory.
## Release notes
+### Version 0.6
+
+- Add the `ssp_rng_proxy_create2` function that allows to tune the sub sets of
+ pseudo random numbers that the proxy generator can use. Pseudo random numbers
+ that do not lie in these partitions are skipped by the proxy. Thanks to this
+ functionality, on can create several proxies, each generating its own set of
+ pseudo random numbers that does not overlap the sequences of the other
+ proxies.
+- Update the version of the RSys dependency to 0.6: replace the deprecated
+ `[N]CHECK` macros by the new macro `CHK`.
+
### Version 0.5
-- Rename the ssp_ran_uniform_disk API call into ssp_ran_uniform_disk_local.
+- Rename the `ssp_ran_uniform_disk` API call into `ssp_ran_uniform_disk_local`.
- Add a more general version of the uniform disk random variate allowing
users to provide the disk's normal.
- Add a float equivalent for all the already defined double random variates.
diff --git a/cmake/CMakeLists.txt b/cmake/CMakeLists.txt
@@ -44,8 +44,9 @@ get_filename_component(_current_source_dir ${CMAKE_CURRENT_LIST_FILE} PATH)
set(Random123_DIR ${_current_source_dir}/)
find_package(Random123 REQUIRED)
-find_package(RCMake 0.2.3 REQUIRED)
-find_package(RSys 0.4 REQUIRED)
+find_package(RCMake 0.4 REQUIRED)
+find_package(RSys 0.6 REQUIRED)
+
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${RCMAKE_SOURCE_DIR})
include(rcmake)
include(rcmake_runtime)
@@ -70,7 +71,7 @@ rcmake_append_runtime_dirs(_runtime_dirs RSys ${Boost_LIBRARY_DIRS})
# Configure and define targets
################################################################################
set(VERSION_MAJOR 0)
-set(VERSION_MINOR 5)
+set(VERSION_MINOR 6)
set(VERSION_PATCH 0)
set(VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH})
@@ -128,7 +129,7 @@ if(NOT NO_TEST)
${SSP_SOURCE_DIR}/${_name}.c
${SSP_SOURCE_DIR}/${_name}.h
${SSP_SOURCE_DIR}/test_ssp_utils.h)
- set_source_files_properties(${SSP_SOURCE_DIR}/${_name}.c PROPERTIES LANGUAGE CXX)
+
target_link_libraries(${_name} ssp RSys ${MATH_LIB})
set(_libraries ${ARGN})
foreach(_lib ${_libraries})
diff --git a/src/ssp.h b/src/ssp.h
@@ -236,6 +236,16 @@ ssp_rng_proxy_create_from_rng
struct ssp_rng_proxy** proxy);
SSP_API res_T
+ssp_rng_proxy_create2
+ (struct mem_allocator* mem_allocator,
+ const struct ssp_rng_type* type,
+ const size_t sequence_offset, /* #RNs before the 1st valid sequence */
+ const size_t sequence_size, /* #RNs in a sequence */
+ const size_t sequence_pitch, /* #RNs between 2 consecutive sequence */
+ const size_t nbuckets, /* #buckets in sequence */
+ struct ssp_rng_proxy** out_proxy);
+
+SSP_API res_T
ssp_rng_proxy_read
(struct ssp_rng_proxy* proxy,
FILE* stream);
diff --git a/src/ssp_ran.c b/src/ssp_ran.c
@@ -49,7 +49,7 @@ cosf2sinf(const float d)
double
ssp_ran_exp(struct ssp_rng* rng, const double mu)
{
- ASSERT(rng && mu > 0);
+ ASSERT(rng && mu >= 0);
rng_cxx rng_cxx(*rng);
RAN_NAMESPACE::exponential_distribution<double> distribution(mu);
return distribution(rng_cxx);
@@ -58,7 +58,7 @@ ssp_ran_exp(struct ssp_rng* rng, const double mu)
float
ssp_ran_exp_float(struct ssp_rng* rng, const float mu)
{
- ASSERT(rng && mu > 0);
+ ASSERT(rng && mu >= 0);
rng_cxx rng_cxx(*rng);
RAN_NAMESPACE::exponential_distribution<float> distribution(mu);
return distribution(rng_cxx);
@@ -67,14 +67,14 @@ ssp_ran_exp_float(struct ssp_rng* rng, const float mu)
double
ssp_ran_exp_pdf(const double x, const double mu)
{
- ASSERT(x >= 0 && mu > 0);
+ ASSERT(x >= 0 && mu >= 0);
return mu * exp(-x * mu);
}
float
ssp_ran_exp_float_pdf(const float x, const float mu)
{
- ASSERT(x >= 0 && mu > 0);
+ ASSERT(x >= 0 && mu >= 0);
return mu * expf(-x * mu);
}
@@ -490,4 +490,4 @@ ssp_ran_uniform_disk_float_local
pt[2] = 0;
if (pdf) *pdf = 1 / (radius * radius);
return pt;
-}
-\ No newline at end of file
+}
diff --git a/src/ssp_rng.c b/src/ssp_rng.c
@@ -73,7 +73,7 @@ static res_T
rng_kiss_set(void* data, const uint64_t seed)
{
struct rng_kiss* kiss = (struct rng_kiss*)data;
- RAN_NAMESPACE::mt19937 rng_mt(seed % UINT32_MAX);
+ RAN_NAMESPACE::mt19937 rng_mt(uint32_t(seed % UINT32_MAX));
ASSERT(kiss);
kiss->x = (uint32_t)rng_mt();
do {
diff --git a/src/ssp_rng_proxy.c b/src/ssp_rng_proxy.c
@@ -38,7 +38,7 @@
#include <limits.h>
-#define BUCKET_SIZE 1000000
+#define BUCKET_SIZE_DEFAULT 1000000
/* FIFO list of RNG states */
struct rng_state_cache {
@@ -56,12 +56,13 @@ enum rng_proxy_sig {
/* A proxy manages a list of N independent RNGs of the same type named buckets.
* One ensure that each bucket have independent `infinite' random numbers by
* partitioning a unique random sequence in N random pools, each containing
- * BUCKET_SIZE random numbers. When a bucket has no more random number in its
- * affected pool, it silently retrieves a new pool of BUCKET_SIZE random
+ * `bucket_size' random numbers. When a bucket has no more random number in its
+ * affected pool, it silently retrieves a new pool of `bucket_size' random
* numbers from the proxy.
*
* Mapping of the partitions of the unique random sequence to N buckets
- * BUCKET_SIZE
+ *
+ * bucket_size
* / \
* +---------+---------+- -+---------+---------+---------+-
* | Bucket0 | Bucket1 | ... |BucketN-1| Bucket0 | Bucket1 | ...
@@ -74,6 +75,8 @@ struct ssp_rng_proxy {
/* The following arrays have the same size */
ATOMIC* buckets; /* Flag that defines which bucket RNGs are created */
+ size_t sequence_bias; /* #RNs to discard between 2 consecutive sequence */
+ size_t bucket_size; /* #random numbers per bucket */
struct ssp_rng** pools; /* `type' RNGs wrapped by bucket RNGs */
struct rng_state_cache* states; /* Cache of `type' RNG states */
@@ -84,18 +87,21 @@ struct ssp_rng_proxy {
ref_T ref;
};
-/* Return a RNG with a pool of BUCKET_SIZE indenpendant random numbers. Each
+/* Return a RNG with a pool of `bucket_size' indenpendant random numbers. Each
* pool are ensure to be independant per `bucket_id' in [0, N) and per function
* call, i.e. calling this function X times with the same bucket_id will
* provide X different random pools.
*
- * BUCKET_SIZE
- * / \
- * +------------+- -+------------+------------+-
- * | Bucket 0 | ... | Bucket N-1 | Bucket 0 | ...
- * | 1st pool | | 1st pool | 2nd pool |
- * +------------+- -+------------+------------+-
- * Unique random sequences */
+ * bucket_size sequence_bias
+ * / \ / \
+ * +------+------------+- -+------------+----+------------+-
+ * |######| Bucket 0 | ... | Bucket N-1 |####| Bucket 0 | ...
+ * |######| 1st pool | | 1st pool |####| 2nd pool |
+ * +------+------------+- -+------------+----+------------+-
+ * \ / \_________sequence_size_______/ /
+ * sequence \________sequence_pitch__________/
+ * offset
+ */
static struct ssp_rng*
rng_proxy_next_ran_pool
(struct ssp_rng_proxy* proxy,
@@ -167,7 +173,7 @@ rng_state_cache_write(struct rng_state_cache* cache, struct ssp_rng* rng)
* RNG that control the scheduling of random number pools for a given bucket
******************************************************************************/
struct rng_bucket {
- struct ssp_rng* pool; /* Wrapped RNG providing a pool of BUCKET_SIZE RNs */
+ struct ssp_rng* pool; /* Wrapped RNG providing a pool of `bucket_size' RNs */
struct ssp_rng_proxy* proxy; /* The RNG proxy */
size_t name; /* Unique bucket identifier in [0, #buckets) */
size_t count; /* Remaining unique random numbers in `pool' */
@@ -190,7 +196,7 @@ rng_bucket_next_ran_pool(struct rng_bucket* rng)
{
ASSERT(rng);
rng->pool = rng_proxy_next_ran_pool(rng->proxy, rng->name);
- rng->count = BUCKET_SIZE;
+ rng->count = rng->proxy->bucket_size;
}
static res_T
@@ -301,8 +307,10 @@ rng_proxy_next_ran_pool
FOR_EACH(ibucket, 0, sa_size(proxy->states)) {
res = rng_state_cache_write(proxy->states + ibucket, proxy->rng);
if(res != RES_OK) FATAL("RNG proxy: cannot write to state cache\n");
- ssp_rng_discard(proxy->rng, BUCKET_SIZE);
+ ssp_rng_discard(proxy->rng, proxy->bucket_size);
}
+ /* Discard RNs to reach the next sequence */
+ ssp_rng_discard(proxy->rng, proxy->sequence_bias);
}
/* Read the RNG pool state of `bucket_name' */
@@ -385,12 +393,28 @@ ssp_rng_proxy_create
const size_t nbuckets,
struct ssp_rng_proxy** out_proxy)
{
+ const size_t sz = BUCKET_SIZE_DEFAULT * nbuckets;
+ return ssp_rng_proxy_create2
+ (mem_allocator, type, 0, sz, sz, nbuckets, out_proxy);
+}
+
+res_T
+ssp_rng_proxy_create2
+ (struct mem_allocator* mem_allocator,
+ const struct ssp_rng_type* type,
+ const size_t sequence_offset, /* #RNs before the 1st valid sequence */
+ const size_t sequence_size, /* #RNs in a sequence */
+ const size_t sequence_pitch, /* #RNs between 2 consecutive sequences */
+ const size_t nbuckets, /* #buckets in a sequence */
+ struct ssp_rng_proxy** out_proxy)
+{
struct mem_allocator* allocator = NULL;
struct ssp_rng_proxy* proxy = NULL;
size_t i;
res_T res = RES_OK;
- if(!type || !out_proxy || !nbuckets) {
+ if(!type || !out_proxy || !sequence_size || sequence_pitch < sequence_size
+ || !nbuckets || sequence_size < nbuckets) {
res = RES_BAD_ARG;
goto error;
}
@@ -404,11 +428,16 @@ ssp_rng_proxy_create
}
proxy->allocator = allocator;
ref_init(&proxy->ref);
+ proxy->bucket_size = sequence_size / nbuckets;
+ proxy->sequence_bias = sequence_pitch - (proxy->bucket_size * nbuckets);
res = ssp_rng_create(allocator, type, &proxy->rng);
if(res != RES_OK) goto error;
proxy->type = *type;
+ res = ssp_rng_discard(proxy->rng, sequence_offset);
+ if(res != RES_OK) goto error;
+
proxy->mutex = mutex_create();
if(!proxy->mutex) {
res = RES_MEM_ERR;
@@ -461,6 +490,8 @@ ssp_rng_proxy_create_from_rng
}
proxy->allocator = allocator;
ref_init(&proxy->ref);
+ proxy->bucket_size = BUCKET_SIZE_DEFAULT;
+ proxy->sequence_bias = 1;
res = ssp_rng_get_type(rng, &type);
if(res != RES_OK) goto error;
diff --git a/src/test_ssp_ran_discrete.c b/src/test_ssp_ran_discrete.c
@@ -50,61 +50,61 @@ main(int argc, char** argv)
(void)argc, (void)argv;
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng), RES_OK);
+ CHK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng) == RES_OK);
- CHECK(ssp_ranst_discrete_create(NULL, NULL), RES_BAD_ARG);
- CHECK(ssp_ranst_discrete_create(NULL, &ran), RES_OK);
+ CHK(ssp_ranst_discrete_create(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssp_ranst_discrete_create(NULL, &ran) == RES_OK);
- CHECK(ssp_ranst_discrete_ref_get(NULL), RES_BAD_ARG);
- CHECK(ssp_ranst_discrete_ref_get(ran), RES_OK);
- CHECK(ssp_ranst_discrete_ref_put(NULL), RES_BAD_ARG);
- CHECK(ssp_ranst_discrete_ref_put(ran), RES_OK);
- CHECK(ssp_ranst_discrete_ref_put(ran), RES_OK);
+ CHK(ssp_ranst_discrete_ref_get(NULL) == RES_BAD_ARG);
+ CHK(ssp_ranst_discrete_ref_get(ran) == RES_OK);
+ CHK(ssp_ranst_discrete_ref_put(NULL) == RES_BAD_ARG);
+ CHK(ssp_ranst_discrete_ref_put(ran) == RES_OK);
+ CHK(ssp_ranst_discrete_ref_put(ran) == RES_OK);
- CHECK(ssp_ranst_discrete_create(&allocator, &ran), RES_OK);
+ CHK(ssp_ranst_discrete_create(&allocator, &ran) == RES_OK);
- CHECK(ssp_ranst_discrete_setup(NULL, NULL, 0), RES_BAD_ARG);
- CHECK(ssp_ranst_discrete_setup(ran, NULL, 0), RES_BAD_ARG);
- CHECK(ssp_ranst_discrete_setup(NULL, weights, 0), RES_BAD_ARG);
- CHECK(ssp_ranst_discrete_setup(ran, weights, 0), RES_BAD_ARG);
- CHECK(ssp_ranst_discrete_setup(NULL, NULL, nweights), RES_BAD_ARG);
- CHECK(ssp_ranst_discrete_setup(ran, NULL, nweights), RES_BAD_ARG);
- CHECK(ssp_ranst_discrete_setup(NULL, weights, nweights), RES_BAD_ARG);
- CHECK(ssp_ranst_discrete_setup(ran, weights, nweights), RES_OK);
+ CHK(ssp_ranst_discrete_setup(NULL, NULL, 0) == RES_BAD_ARG);
+ CHK(ssp_ranst_discrete_setup(ran, NULL, 0) == RES_BAD_ARG);
+ CHK(ssp_ranst_discrete_setup(NULL, weights, 0) == RES_BAD_ARG);
+ CHK(ssp_ranst_discrete_setup(ran, weights, 0) == RES_BAD_ARG);
+ CHK(ssp_ranst_discrete_setup(NULL, NULL, nweights) == RES_BAD_ARG);
+ CHK(ssp_ranst_discrete_setup(ran, NULL, nweights) == RES_BAD_ARG);
+ CHK(ssp_ranst_discrete_setup(NULL, weights, nweights) == RES_BAD_ARG);
+ CHK(ssp_ranst_discrete_setup(ran, weights, nweights) == RES_OK);
memset(tmp, 0, sizeof(tmp));
FOR_EACH(i, 0, NSAMPS) {
const size_t k = ssp_ranst_discrete_get(rng, ran);
double pdf;
- CHECK(k < nweights, 1);
+ CHK(k < nweights);
pdf = ssp_ranst_discrete_pdf(k, ran);
++tmp[k];
- CHECK(pdf, weights[k]);
- CHECK(pdf >= 0.f, 1);
- CHECK(pdf <= 1.f, 1);
+ CHK(pdf == weights[k]);
+ CHK(pdf >= 0.f);
+ CHK(pdf <= 1.f);
}
FOR_EACH(i, 0, nweights) {
- NCHECK(tmp[i], 0);
+ CHK(tmp[i] != 0);
}
- CHECK(ssp_ranst_discrete_setup(ran, weights, nweights-1), RES_OK);
+ CHK(ssp_ranst_discrete_setup(ran, weights, nweights-1) == RES_OK);
FOR_EACH(i, 0, NSAMPS) {
const size_t k = ssp_ranst_discrete_get(rng, ran);
double pdf;
- CHECK(k < nweights-1, 1);
+ CHK(k < nweights-1);
pdf = ssp_ranst_discrete_pdf(k, ran);
- CHECK(pdf >= 0.f, 1);
- CHECK(pdf <= 1.f, 1);
+ CHK(pdf >= 0.f);
+ CHK(pdf <= 1.f);
}
accum = 0;
FOR_EACH(i, 0, nweights-1) accum += ssp_ranst_discrete_pdf(i, ran);
- CHECK(eq_eps(accum, 1, 1.e-8), 1);
- CHECK(ssp_ranst_discrete_ref_put(ran), RES_OK);
+ CHK(eq_eps(accum, 1, 1.e-8) == 1);
+ CHK(ssp_ranst_discrete_ref_put(ran) == RES_OK);
- CHECK(ssp_rng_ref_put(rng), RES_OK);
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssp_ran_gaussian.h b/src/test_ssp_ran_gaussian.h
@@ -43,31 +43,31 @@
#endif /* TEST_SSP_RAN_GAUSSIAN_H */
#if TYPE_FLOAT==0
-#define REAL double
-#define TEST test_double
-#define RAN_GAUSSIAN ssp_ran_gaussian
-#define RANST_GAUSSIAN ssp_ranst_gaussian
-#define RANST_GAUSSIAN_CREATE ssp_ranst_gaussian_create
-#define RANST_GAUSSIAN_REF_GET ssp_ranst_gaussian_ref_get
-#define RANST_GAUSSIAN_REF_PUT ssp_ranst_gaussian_ref_put
-#define RANST_GAUSSIAN_SETUP ssp_ranst_gaussian_setup
-#define RANST_GAUSSIAN_GET ssp_ranst_gaussian_get
-#define SQRT sqrt
+ #define REAL double
+ #define TEST test_double
+ #define RAN_GAUSSIAN ssp_ran_gaussian
+ #define RANST_GAUSSIAN ssp_ranst_gaussian
+ #define RANST_GAUSSIAN_CREATE ssp_ranst_gaussian_create
+ #define RANST_GAUSSIAN_REF_GET ssp_ranst_gaussian_ref_get
+ #define RANST_GAUSSIAN_REF_PUT ssp_ranst_gaussian_ref_put
+ #define RANST_GAUSSIAN_SETUP ssp_ranst_gaussian_setup
+ #define RANST_GAUSSIAN_GET ssp_ranst_gaussian_get
+ #define SQRT sqrt
#elif TYPE_FLOAT==1
-#define REAL float
-#define TEST test_float
-#define RAN_GAUSSIAN ssp_ran_gaussian_float
-#define RANST_GAUSSIAN ssp_ranst_gaussian_float
-#define RANST_GAUSSIAN_CREATE ssp_ranst_gaussian_float_create
-#define RANST_GAUSSIAN_REF_GET ssp_ranst_gaussian_float_ref_get
-#define RANST_GAUSSIAN_REF_PUT ssp_ranst_gaussian_float_ref_put
-#define RANST_GAUSSIAN_SETUP ssp_ranst_gaussian_float_setup
-#define RANST_GAUSSIAN_GET ssp_ranst_gaussian_float_get
-#define SQRT sqrtf
+ #define REAL float
+ #define TEST test_float
+ #define RAN_GAUSSIAN ssp_ran_gaussian_float
+ #define RANST_GAUSSIAN ssp_ranst_gaussian_float
+ #define RANST_GAUSSIAN_CREATE ssp_ranst_gaussian_float_create
+ #define RANST_GAUSSIAN_REF_GET ssp_ranst_gaussian_float_ref_get
+ #define RANST_GAUSSIAN_REF_PUT ssp_ranst_gaussian_float_ref_put
+ #define RANST_GAUSSIAN_SETUP ssp_ranst_gaussian_float_setup
+ #define RANST_GAUSSIAN_GET ssp_ranst_gaussian_float_get
+ #define SQRT (float)sqrt
#else
-#error "TYPE_SUFFIX must be defined either 0 or 1"
+ #error "TYPE_FLOAT must be defined either 0 or 1"
#endif
static void
@@ -85,24 +85,24 @@ TEST()
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssp_rng_create(&allocator, &ssp_rng_mt19937_64, &rng), RES_OK);
+ CHK(ssp_rng_create(&allocator, &ssp_rng_mt19937_64, &rng) == RES_OK);
- CHECK(RANST_GAUSSIAN_CREATE(NULL, NULL), RES_BAD_ARG);
- CHECK(RANST_GAUSSIAN_CREATE(NULL, &gaussian), RES_OK);
- CHECK(RANST_GAUSSIAN_REF_PUT(gaussian), RES_OK);
+ CHK(RANST_GAUSSIAN_CREATE(NULL, NULL) == RES_BAD_ARG);
+ CHK(RANST_GAUSSIAN_CREATE(NULL, &gaussian) == RES_OK);
+ CHK(RANST_GAUSSIAN_REF_PUT(gaussian) == RES_OK);
- CHECK(RANST_GAUSSIAN_CREATE(&allocator, NULL), RES_BAD_ARG);
- CHECK(RANST_GAUSSIAN_CREATE(&allocator, &gaussian), RES_OK);
+ CHK(RANST_GAUSSIAN_CREATE(&allocator, NULL) == RES_BAD_ARG);
+ CHK(RANST_GAUSSIAN_CREATE(&allocator, &gaussian) == RES_OK);
- CHECK(RANST_GAUSSIAN_SETUP(NULL, exp_mean, exp_std), RES_BAD_ARG);
- CHECK(RANST_GAUSSIAN_SETUP(gaussian, exp_mean, -1), RES_BAD_ARG);
- CHECK(RANST_GAUSSIAN_SETUP(gaussian, exp_mean, exp_std), RES_OK);
+ CHK(RANST_GAUSSIAN_SETUP(NULL, exp_mean, exp_std) == RES_BAD_ARG);
+ CHK(RANST_GAUSSIAN_SETUP(gaussian, exp_mean, -1) == RES_BAD_ARG);
+ CHK(RANST_GAUSSIAN_SETUP(gaussian, exp_mean, exp_std) == RES_OK);
- CHECK(RANST_GAUSSIAN_REF_GET(NULL), RES_BAD_ARG);
- CHECK(RANST_GAUSSIAN_REF_GET(gaussian), RES_OK);
+ CHK(RANST_GAUSSIAN_REF_GET(NULL) == RES_BAD_ARG);
+ CHK(RANST_GAUSSIAN_REF_GET(gaussian) == RES_OK);
- CHECK(RANST_GAUSSIAN_REF_PUT(NULL), RES_BAD_ARG);
- CHECK(RANST_GAUSSIAN_REF_PUT(gaussian), RES_OK);
+ CHK(RANST_GAUSSIAN_REF_PUT(NULL) == RES_BAD_ARG);
+ CHK(RANST_GAUSSIAN_REF_PUT(gaussian) == RES_OK);
time_current(&start);
FOR_EACH(i, 0, NBS) {
@@ -118,8 +118,8 @@ TEST()
mean = x / NBS;
std = SQRT(x2 / NBS - mean*mean);
printf("%g %g\n", mean, std);
- CHECK(eq_eps(mean, exp_mean, 1e-2), 1);
- CHECK(eq_eps(std, exp_std, 1e-2), 1);
+ CHK(eq_eps(mean, exp_mean, 1e-2) == 1);
+ CHK(eq_eps(std, exp_std, 1e-2) == 1);
/* Same test with inline gaussian generation */
x = 0;
@@ -139,16 +139,16 @@ TEST()
mean = x / NBS;
std = SQRT(x2 / NBS - mean*mean);
printf("%g %g\n", mean, std);
- CHECK(eq_eps(mean, exp_mean, 1.e-2), 1);
- CHECK(eq_eps(std, exp_std, 1e-2), 1);
+ CHK(eq_eps(mean, exp_mean, 1.e-2) == 1);
+ CHK(eq_eps(std, exp_std, 1e-2) == 1);
- CHECK(RANST_GAUSSIAN_REF_PUT(gaussian), RES_OK);
+ CHK(RANST_GAUSSIAN_REF_PUT(gaussian) == RES_OK);
- CHECK(ssp_rng_ref_put(rng), RES_OK);
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
}
#undef TEST
diff --git a/src/test_ssp_ran_hemisphere.h b/src/test_ssp_ran_hemisphere.h
@@ -40,51 +40,51 @@
#endif /* TEST_SSP_RAN_HEMISPHERE_H */
#if TYPE_FLOAT==0
-#define REAL double
-#define TEST test_double
-#define RNG_UNIFORM_R ssp_rng_uniform_double
-#define RAN_HEMISPHERE_UNIFORM_LOCAL ssp_ran_hemisphere_uniform_local
-#define RAN_HEMISPHERE_UNIFORM_LOCAL_PDF ssp_ran_hemisphere_uniform_local_pdf
-#define RAN_HEMISPHERE_COS_LOCAL ssp_ran_hemisphere_cos_local
-#define RAN_HEMISPHERE_COS_LOCAL_PDF ssp_ran_hemisphere_cos_local_pdf
-#define RAN_HEMISPHERE_UNIFORM ssp_ran_hemisphere_uniform
-#define RAN_HEMISPHERE_COS ssp_ran_hemisphere_cos
-#define RAN_HEMISPHERE_COS_PDF ssp_ran_hemisphere_cos_pdf
-#define RAN_HEMISPHERE_UNIFORM_PDF ssp_ran_hemisphere_uniform_pdf
-#define R3_NORMALIZE d3_normalize
-#define R3_IS_NORMALIZED d3_is_normalized
-#define R3_DOT d3_dot
-#define R4_EQ_EPS d4_eq_eps
-#define R4_EQ d4_eq
-#define R3_EQ_EPS d3_eq_eps
-#define EQ_EPS_R eq_eps
-#define R33_BASIS d33_basis
-#define R33_MULR3 d33_muld3
+ #define REAL double
+ #define TEST test_double
+ #define RNG_UNIFORM_R ssp_rng_uniform_double
+ #define RAN_HEMISPHERE_UNIFORM_LOCAL ssp_ran_hemisphere_uniform_local
+ #define RAN_HEMISPHERE_UNIFORM_LOCAL_PDF ssp_ran_hemisphere_uniform_local_pdf
+ #define RAN_HEMISPHERE_COS_LOCAL ssp_ran_hemisphere_cos_local
+ #define RAN_HEMISPHERE_COS_LOCAL_PDF ssp_ran_hemisphere_cos_local_pdf
+ #define RAN_HEMISPHERE_UNIFORM ssp_ran_hemisphere_uniform
+ #define RAN_HEMISPHERE_COS ssp_ran_hemisphere_cos
+ #define RAN_HEMISPHERE_COS_PDF ssp_ran_hemisphere_cos_pdf
+ #define RAN_HEMISPHERE_UNIFORM_PDF ssp_ran_hemisphere_uniform_pdf
+ #define R3_NORMALIZE d3_normalize
+ #define R3_IS_NORMALIZED d3_is_normalized
+ #define R3_DOT d3_dot
+ #define R4_EQ_EPS d4_eq_eps
+ #define R4_EQ d4_eq
+ #define R3_EQ_EPS d3_eq_eps
+ #define EQ_EPS_R eq_eps
+ #define R33_BASIS d33_basis
+ #define R33_MULR3 d33_muld3
#elif TYPE_FLOAT==1
-#define REAL float
-#define TEST test_float
-#define RNG_UNIFORM_R ssp_rng_uniform_float
-#define RAN_HEMISPHERE_UNIFORM_LOCAL ssp_ran_hemisphere_uniform_float_local
-#define RAN_HEMISPHERE_UNIFORM_LOCAL_PDF ssp_ran_hemisphere_uniform_float_local_pdf
-#define RAN_HEMISPHERE_COS_LOCAL ssp_ran_hemisphere_cos_float_local
-#define RAN_HEMISPHERE_COS_LOCAL_PDF ssp_ran_hemisphere_cos_float_local_pdf
-#define RAN_HEMISPHERE_UNIFORM ssp_ran_hemisphere_uniform_float
-#define RAN_HEMISPHERE_COS ssp_ran_hemisphere_cos_float
-#define RAN_HEMISPHERE_COS_PDF ssp_ran_hemisphere_cos_float_pdf
-#define RAN_HEMISPHERE_UNIFORM_PDF ssp_ran_hemisphere_uniform_float_pdf
-#define R3_NORMALIZE f3_normalize
-#define R3_IS_NORMALIZED f3_is_normalized
-#define R3_DOT f3_dot
-#define R4_EQ_EPS f4_eq_eps
-#define R4_EQ f4_eq
-#define R3_EQ_EPS f3_eq_eps
-#define EQ_EPS_R eq_eps
-#define R33_BASIS f33_basis
-#define R33_MULR3 f33_mulf3
+ #define REAL float
+ #define TEST test_float
+ #define RNG_UNIFORM_R ssp_rng_uniform_float
+ #define RAN_HEMISPHERE_UNIFORM_LOCAL ssp_ran_hemisphere_uniform_float_local
+ #define RAN_HEMISPHERE_UNIFORM_LOCAL_PDF ssp_ran_hemisphere_uniform_float_local_pdf
+ #define RAN_HEMISPHERE_COS_LOCAL ssp_ran_hemisphere_cos_float_local
+ #define RAN_HEMISPHERE_COS_LOCAL_PDF ssp_ran_hemisphere_cos_float_local_pdf
+ #define RAN_HEMISPHERE_UNIFORM ssp_ran_hemisphere_uniform_float
+ #define RAN_HEMISPHERE_COS ssp_ran_hemisphere_cos_float
+ #define RAN_HEMISPHERE_COS_PDF ssp_ran_hemisphere_cos_float_pdf
+ #define RAN_HEMISPHERE_UNIFORM_PDF ssp_ran_hemisphere_uniform_float_pdf
+ #define R3_NORMALIZE f3_normalize
+ #define R3_IS_NORMALIZED f3_is_normalized
+ #define R3_DOT f3_dot
+ #define R4_EQ_EPS f4_eq_eps
+ #define R4_EQ f4_eq
+ #define R3_EQ_EPS f3_eq_eps
+ #define EQ_EPS_R eq_eps
+ #define R33_BASIS f33_basis
+ #define R33_MULR3 f33_mulf3
#else
-#error "TYPE_SUFFIX must be defined either 0 or 1"
+ #error "TYPE_FLOAT must be defined either 0 or 1"
#endif
static void
@@ -101,8 +101,8 @@ TEST()
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssp_rng_create(&allocator, &ssp_rng_mt19937_64, &rng0), RES_OK);
- CHECK(ssp_rng_create(&allocator, &ssp_rng_mt19937_64, &rng1), RES_OK);
+ CHK(ssp_rng_create(&allocator, &ssp_rng_mt19937_64, &rng0) == RES_OK);
+ CHK(ssp_rng_create(&allocator, &ssp_rng_mt19937_64, &rng1) == RES_OK);
samps0[0][0] = 0; samps0[0][1] = 0; samps0[0][2] = 1;
f = RAN_HEMISPHERE_UNIFORM(rng1, samps0[0], samps1[0], NULL);
@@ -117,16 +117,16 @@ TEST()
ssp_rng_set(rng1, seed);
f = RAN_HEMISPHERE_UNIFORM_LOCAL(rng1, samps0[i], &samps0[i][3]);
- CHECK(f, samps0[i]);
- CHECK(R3_IS_NORMALIZED(f), 1);
- CHECK(EQ_EPS_R(f[3], (1/(2*(REAL)PI)), (REAL)1.e-6), 1);
- CHECK(EQ_EPS_R(f[3], RAN_HEMISPHERE_UNIFORM_LOCAL_PDF(f), (REAL)1.e-6), 1);
- CHECK(R3_DOT(f, up) >= 0, 1);
+ CHK(f == samps0[i]);
+ CHK(R3_IS_NORMALIZED(f));
+ CHK(EQ_EPS_R(f[3], (1/(2*(REAL)PI)), (REAL)1.e-6) == 1);
+ CHK(EQ_EPS_R(f[3], RAN_HEMISPHERE_UNIFORM_LOCAL_PDF(f), (REAL)1.e-6) == 1);
+ CHK(R3_DOT(f, up) >= 0);
ssp_rng_set(rng1, seed);
f = RAN_HEMISPHERE_UNIFORM(rng1, up, samps1[i], &samps1[i][3]);
- CHECK(f, samps1[i]);
- CHECK(R4_EQ_EPS(f, samps0[i], (REAL)1.e-6), 1);
+ CHK(f == samps1[i]);
+ CHK(R4_EQ_EPS(f, samps0[i], (REAL)1.e-6) == 1);
up[0] = RNG_UNIFORM_R(rng1, -1, 1);
up[1] = RNG_UNIFORM_R(rng1, -1, 1);
@@ -135,18 +135,18 @@ TEST()
ssp_rng_set(rng1, seed);
f = RAN_HEMISPHERE_UNIFORM(rng1, up, samps1[i], &samps1[i][3]);
- CHECK(R3_EQ_EPS(samps0[i], samps1[i], (REAL)1.e-6), 0);
- CHECK(R3_IS_NORMALIZED(f), 1);
- CHECK(R3_DOT(f, up) >= 0, 1);
- CHECK(EQ_EPS_R(f[3], 1/(2*(REAL)PI), (REAL)1.e-6 ), 1);
- CHECK(EQ_EPS_R(f[3], RAN_HEMISPHERE_UNIFORM_PDF(up, f), (REAL)1.e-6), 1);
+ CHK(R3_EQ_EPS(samps0[i], samps1[i], (REAL)1.e-6) == 0);
+ CHK(R3_IS_NORMALIZED(f));
+ CHK(R3_DOT(f, up) >= 0);
+ CHK(EQ_EPS_R(f[3], 1/(2*(REAL)PI), (REAL)1.e-6 ));
+ CHK(EQ_EPS_R(f[3], RAN_HEMISPHERE_UNIFORM_PDF(up, f), (REAL)1.e-6));
R33_BASIS(frame, up);
R33_MULR3(xyz, frame, samps0[i]);
- CHECK(R3_EQ_EPS(samps1[i], xyz, (REAL)1.e-6), 1);
+ CHK(R3_EQ_EPS(samps1[i], xyz, (REAL)1.e-6) == 1);
FOR_EACH(j, 0, i) {
- CHECK(R3_EQ_EPS(samps0[i], samps0[j], (REAL)1.e-6), 0);
- CHECK(R3_EQ_EPS(samps1[i], samps1[j], (REAL)1.e-6), 0);
+ CHK(R3_EQ_EPS(samps0[i], samps0[j], (REAL)1.e-6) == 0);
+ CHK(R3_EQ_EPS(samps1[i], samps1[j], (REAL)1.e-6) == 0);
}
}
@@ -159,7 +159,7 @@ TEST()
RAN_HEMISPHERE_UNIFORM(rng0, samps1[1], samps0[0], &samps0[0][3]);
ssp_rng_set(rng0, 0);
RAN_HEMISPHERE_UNIFORM(rng0, samps1[1], samps1[1], &samps1[1][3]);
- CHECK(R4_EQ(samps0[0], samps1[1]), 1);
+ CHK(R4_EQ(samps0[0], samps1[1]) == 1);
ssp_rng_set(rng0, 0);
FOR_EACH(i, 0, NSAMPS) {
@@ -170,17 +170,17 @@ TEST()
ssp_rng_set(rng1, seed);
f = RAN_HEMISPHERE_COS_LOCAL(rng1, samps2[i], &samps2[i][3]);
- CHECK(f, samps2[i]);
- CHECK(R3_EQ_EPS(samps0[i], samps2[i], (REAL)1.e-6), 0);
- CHECK(R3_IS_NORMALIZED(f), 1);
- CHECK(EQ_EPS_R(f[3], f[2]/(REAL)PI, (REAL)1.e-6), 1);
- CHECK(EQ_EPS_R(f[3], RAN_HEMISPHERE_COS_LOCAL_PDF(f), (REAL)1.e-6), 1);
- CHECK(R3_DOT(f, up) >= 0, 1);
+ CHK(f == samps2[i]);
+ CHK(R3_EQ_EPS(samps0[i], samps2[i], (REAL)1.e-6) == 0);
+ CHK(R3_IS_NORMALIZED(f) == 1);
+ CHK(EQ_EPS_R(f[3], f[2]/(REAL)PI, (REAL)1.e-6) == 1);
+ CHK(EQ_EPS_R(f[3], RAN_HEMISPHERE_COS_LOCAL_PDF(f), (REAL)1.e-6) == 1);
+ CHK(R3_DOT(f, up) >= 0);
ssp_rng_set(rng1, seed);
f = RAN_HEMISPHERE_COS(rng1, up, samps3[i], &samps3[i][3]);
- CHECK(f, samps3[i]);
- CHECK(R4_EQ_EPS(f, samps2[i], (REAL)1.e-6), 1);
+ CHK(f == samps3[i]);
+ CHK(R4_EQ_EPS(f, samps2[i], (REAL)1.e-6) == 1);
up[0] = RNG_UNIFORM_R(rng1, -1, 1);
up[1] = RNG_UNIFORM_R(rng1, -1, 1);
@@ -189,19 +189,19 @@ TEST()
ssp_rng_set(rng1, seed);
f = RAN_HEMISPHERE_COS(rng1, up, samps3[i], &samps3[i][3]);
- CHECK(R3_EQ_EPS(samps2[i], samps3[i], (REAL)1.e-6), 0);
- CHECK(R3_EQ_EPS(samps1[i], samps3[i], (REAL)1.e-6), 0);
- CHECK(R3_IS_NORMALIZED(f), 1);
- CHECK(R3_DOT(f, up) >= 0.f, 1);
- CHECK(EQ_EPS_R(f[3], R3_DOT(f, up)/PI, (REAL)1.e-6), 1);
- CHECK(EQ_EPS_R(f[3], RAN_HEMISPHERE_COS_PDF(f, up), (REAL)1.e-6), 1);
+ CHK(R3_EQ_EPS(samps2[i], samps3[i], (REAL)1.e-6) == 0);
+ CHK(R3_EQ_EPS(samps1[i], samps3[i], (REAL)1.e-6) == 0);
+ CHK(R3_IS_NORMALIZED(f) == 1);
+ CHK(R3_DOT(f, up) >= 0.f);
+ CHK(EQ_EPS_R(f[3], R3_DOT(f, up)/PI, (REAL)1.e-6) == 1);
+ CHK(EQ_EPS_R(f[3], RAN_HEMISPHERE_COS_PDF(f, up), (REAL)1.e-6) == 1);
R33_BASIS(frame, up);
R33_MULR3(xyz, frame, samps2[i]);
- CHECK(R3_EQ_EPS(samps3[i], xyz, (REAL)1.e-6), 1);
+ CHK(R3_EQ_EPS(samps3[i], xyz, (REAL)1.e-6) == 1);
FOR_EACH(j, 0, i) {
- CHECK(R3_EQ_EPS(samps2[i], samps2[j], (REAL)1.e-6), 0);
- CHECK(R3_EQ_EPS(samps3[i], samps3[j], (REAL)1.e-6), 0);
+ CHK(R3_EQ_EPS(samps2[i], samps2[j], (REAL)1.e-6) == 0);
+ CHK(R3_EQ_EPS(samps3[i], samps3[j], (REAL)1.e-6) == 0);
}
}
@@ -214,14 +214,14 @@ TEST()
RAN_HEMISPHERE_COS(rng0, samps1[1], samps0[0], &samps0[0][3]);
ssp_rng_set(rng0, 0);
RAN_HEMISPHERE_COS(rng0, samps1[1], samps1[1], &samps1[1][3]);
- CHECK(R4_EQ(samps0[0], samps1[1]), 1);
+ CHK(R4_EQ(samps0[0], samps1[1]) == 1);
ssp_rng_ref_put(rng0);
ssp_rng_ref_put(rng1);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
}
#undef REAL
diff --git a/src/test_ssp_ran_hg.h b/src/test_ssp_ran_hg.h
@@ -57,7 +57,7 @@
#define EQ_EPS_R eq_epsf
#define R3_DOT f3_dot
#else
-#error "TYPE_SUFFIX must be defined either 0 or 1"
+#error "TYPE_FLOAT must be defined either 0 or 1"
#endif
static void
@@ -69,7 +69,7 @@ TEST()
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng), RES_OK);
+ CHK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng) == RES_OK);
FOR_EACH(i, 0, NG) {
/* for any value of g... */
@@ -89,15 +89,15 @@ TEST()
sum_cos += R3_DOT(up, dir);
}
/* ...on average cos(up, dir) should be g */
- CHECK(EQ_EPS_R(sum_cos_local / NSAMPS, g, (REAL)2.5e-2), 1);
- CHECK(EQ_EPS_R(sum_cos / NSAMPS, g, (REAL)2.5e-2), 1);
+ CHK(EQ_EPS_R(sum_cos_local / NSAMPS, g, (REAL)2.5e-2) == 1);
+ CHK(EQ_EPS_R(sum_cos / NSAMPS, g, (REAL)2.5e-2) == 1);
}
ssp_rng_ref_put(rng);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
}
#undef REAL
diff --git a/src/test_ssp_ran_piecewise_linear.h b/src/test_ssp_ran_piecewise_linear.h
@@ -39,34 +39,34 @@
#endif /* TEST_SSP_RAN_PIECEWISE_LINEAR_H */
#if TYPE_FLOAT==0
-#define REAL double
-#define TEST test_double
-#define RANST_PIECEWISE_LINEAR ssp_ranst_piecewise_linear
-#define RANST_PIECEWISE_LINEAR_CREATE ssp_ranst_piecewise_linear_create
-#define RANST_PIECEWISE_LINEAR_SETUP ssp_ranst_piecewise_linear_setup
-#define RANST_PIECEWISE_LINEAR_GET ssp_ranst_piecewise_linear_get
-#define RANST_PIECEWISE_LINEAR_PDF ssp_ranst_piecewise_linear_pdf
-#define RANST_PIECEWISE_LINEAR_REF_GET ssp_ranst_piecewise_linear_ref_get
-#define RANST_PIECEWISE_LINEAR_REF_PUT ssp_ranst_piecewise_linear_ref_put
-#define EQ_EPS_R eq_eps
-#define EPS_R DBL_EPSILON
-#define SQRT sqrt
+ #define REAL double
+ #define TEST test_double
+ #define RANST_PIECEWISE_LINEAR ssp_ranst_piecewise_linear
+ #define RANST_PIECEWISE_LINEAR_CREATE ssp_ranst_piecewise_linear_create
+ #define RANST_PIECEWISE_LINEAR_SETUP ssp_ranst_piecewise_linear_setup
+ #define RANST_PIECEWISE_LINEAR_GET ssp_ranst_piecewise_linear_get
+ #define RANST_PIECEWISE_LINEAR_PDF ssp_ranst_piecewise_linear_pdf
+ #define RANST_PIECEWISE_LINEAR_REF_GET ssp_ranst_piecewise_linear_ref_get
+ #define RANST_PIECEWISE_LINEAR_REF_PUT ssp_ranst_piecewise_linear_ref_put
+ #define EQ_EPS_R eq_eps
+ #define EPS_R DBL_EPSILON
+ #define SQRT sqrt
#elif TYPE_FLOAT==1
-#define REAL float
-#define TEST test_float
-#define RANST_PIECEWISE_LINEAR ssp_ranst_piecewise_linear_float
-#define RANST_PIECEWISE_LINEAR_CREATE ssp_ranst_piecewise_linear_float_create
-#define RANST_PIECEWISE_LINEAR_SETUP ssp_ranst_piecewise_linear_float_setup
-#define RANST_PIECEWISE_LINEAR_GET ssp_ranst_piecewise_linear_float_get
-#define RANST_PIECEWISE_LINEAR_PDF ssp_ranst_piecewise_linear_float_pdf
-#define RANST_PIECEWISE_LINEAR_REF_GET ssp_ranst_piecewise_linear_float_ref_get
-#define RANST_PIECEWISE_LINEAR_REF_PUT ssp_ranst_piecewise_linear_float_ref_put
-#define EQ_EPS_R eq_epsf
-#define EPS_R FLT_EPSILON
-#define SQRT sqrtf
+ #define REAL float
+ #define TEST test_float
+ #define RANST_PIECEWISE_LINEAR ssp_ranst_piecewise_linear_float
+ #define RANST_PIECEWISE_LINEAR_CREATE ssp_ranst_piecewise_linear_float_create
+ #define RANST_PIECEWISE_LINEAR_SETUP ssp_ranst_piecewise_linear_float_setup
+ #define RANST_PIECEWISE_LINEAR_GET ssp_ranst_piecewise_linear_float_get
+ #define RANST_PIECEWISE_LINEAR_PDF ssp_ranst_piecewise_linear_float_pdf
+ #define RANST_PIECEWISE_LINEAR_REF_GET ssp_ranst_piecewise_linear_float_ref_get
+ #define RANST_PIECEWISE_LINEAR_REF_PUT ssp_ranst_piecewise_linear_float_ref_put
+ #define EQ_EPS_R eq_epsf
+ #define EPS_R FLT_EPSILON
+ #define SQRT (float)sqrt
#else
-#error "TYPE_SUFFIX must be defined either 0 or 1"
+ #error "TYPE_FLOAT must be defined either 0 or 1"
#endif
static void
@@ -84,79 +84,80 @@ TEST()
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssp_rng_create(&allocator, &ssp_rng_mt19937_64, &rng), RES_OK);
+ CHK(ssp_rng_create(&allocator, &ssp_rng_mt19937_64, &rng) == RES_OK);
- CHECK(RANST_PIECEWISE_LINEAR_CREATE(NULL, NULL), RES_BAD_ARG);
- CHECK(RANST_PIECEWISE_LINEAR_CREATE(NULL, &pwl), RES_OK);
- CHECK(RANST_PIECEWISE_LINEAR_REF_PUT(pwl), RES_OK);
+ CHK(RANST_PIECEWISE_LINEAR_CREATE(NULL, NULL) == RES_BAD_ARG);
+ CHK(RANST_PIECEWISE_LINEAR_CREATE(NULL, &pwl) == RES_OK);
+ CHK(RANST_PIECEWISE_LINEAR_REF_PUT(pwl) == RES_OK);
- CHECK(RANST_PIECEWISE_LINEAR_CREATE(&allocator, NULL), RES_BAD_ARG);
- CHECK(RANST_PIECEWISE_LINEAR_CREATE(&allocator, &pwl), RES_OK);
+ CHK(RANST_PIECEWISE_LINEAR_CREATE(&allocator, NULL) == RES_BAD_ARG);
+ CHK(RANST_PIECEWISE_LINEAR_CREATE(&allocator, &pwl) == RES_OK);
- CHECK(RANST_PIECEWISE_LINEAR_SETUP
- (NULL, intervals, weights, sizeof(intervals)/sizeof(REAL)), RES_BAD_ARG);
- CHECK(RANST_PIECEWISE_LINEAR_SETUP
- (pwl, NULL, weights, sizeof(intervals)/sizeof(REAL)), RES_BAD_ARG);
- CHECK(RANST_PIECEWISE_LINEAR_SETUP
- (pwl, intervals, NULL, sizeof(intervals)/sizeof(REAL)), RES_BAD_ARG);
- CHECK(RANST_PIECEWISE_LINEAR_SETUP
- (pwl, intervals, weights, 1), RES_BAD_ARG);
- CHECK(RANST_PIECEWISE_LINEAR_SETUP
- (pwl, intervals, weights, sizeof(intervals)/sizeof(REAL)), RES_OK);
+ CHK(RANST_PIECEWISE_LINEAR_SETUP
+ (NULL, intervals, weights, sizeof(intervals)/sizeof(REAL)) == RES_BAD_ARG);
+ CHK(RANST_PIECEWISE_LINEAR_SETUP
+ (pwl, NULL, weights, sizeof(intervals)/sizeof(REAL)) == RES_BAD_ARG);
+ CHK(RANST_PIECEWISE_LINEAR_SETUP
+ (pwl, intervals, NULL, sizeof(intervals)/sizeof(REAL)) == RES_BAD_ARG);
+ CHK(RANST_PIECEWISE_LINEAR_SETUP
+ (pwl, intervals, weights, 1) == RES_BAD_ARG);
+ CHK(RANST_PIECEWISE_LINEAR_SETUP
+ (pwl, intervals, weights, sizeof(intervals)/sizeof(REAL)) == RES_OK);
- CHECK(RANST_PIECEWISE_LINEAR_REF_PUT(pwl), RES_OK);
- CHECK(RANST_PIECEWISE_LINEAR_CREATE(&allocator, &pwl), RES_OK);
+ CHK(RANST_PIECEWISE_LINEAR_REF_PUT(pwl) == RES_OK);
+ CHK(RANST_PIECEWISE_LINEAR_CREATE(&allocator, &pwl) == RES_OK);
weights[1] = -1;
- CHECK(RANST_PIECEWISE_LINEAR_SETUP
- (pwl, intervals, weights, sizeof(intervals) / sizeof(REAL)), RES_BAD_ARG);
+ CHK(RANST_PIECEWISE_LINEAR_SETUP
+ (pwl, intervals, weights, sizeof(intervals) / sizeof(REAL)) == RES_BAD_ARG);
weights[1] = 1;
intervals[1] = 4;
- CHECK(RANST_PIECEWISE_LINEAR_SETUP
- (pwl, intervals, weights, sizeof(intervals) / sizeof(REAL)), RES_BAD_ARG);
+ CHK(RANST_PIECEWISE_LINEAR_SETUP
+ (pwl, intervals, weights, sizeof(intervals) / sizeof(REAL)) == RES_BAD_ARG);
intervals[1] = 1;
intervals[1] = 3;
- CHECK(RANST_PIECEWISE_LINEAR_SETUP
- (pwl, intervals, weights, sizeof(intervals) / sizeof(REAL)), RES_BAD_ARG);
+ CHK(RANST_PIECEWISE_LINEAR_SETUP
+ (pwl, intervals, weights, sizeof(intervals) / sizeof(REAL)) == RES_BAD_ARG);
intervals[1] = 1;
- CHECK(RANST_PIECEWISE_LINEAR_SETUP
- (pwl, intervals, weights, sizeof(intervals) / sizeof(REAL)), RES_OK);
+ CHK(RANST_PIECEWISE_LINEAR_SETUP
+ (pwl, intervals, weights, sizeof(intervals) / sizeof(REAL)) == RES_OK);
- CHECK(RANST_PIECEWISE_LINEAR_REF_GET(NULL), RES_BAD_ARG);
- CHECK(RANST_PIECEWISE_LINEAR_REF_GET(pwl), RES_OK);
+ CHK(RANST_PIECEWISE_LINEAR_REF_GET(NULL) == RES_BAD_ARG);
+ CHK(RANST_PIECEWISE_LINEAR_REF_GET(pwl) == RES_OK);
- CHECK(RANST_PIECEWISE_LINEAR_REF_PUT(NULL), RES_BAD_ARG);
- CHECK(RANST_PIECEWISE_LINEAR_REF_PUT(pwl), RES_OK);
+ CHK(RANST_PIECEWISE_LINEAR_REF_PUT(NULL) == RES_BAD_ARG);
+ CHK(RANST_PIECEWISE_LINEAR_REF_PUT(pwl) == RES_OK);
FOR_EACH(i, 0, NBS) {
- REAL r = RANST_PIECEWISE_LINEAR_GET(pwl, rng);
- CHECK(0 <= r && r <= 10, 1);
- REAL pdf = RANST_PIECEWISE_LINEAR_PDF(pwl, r);
- CHECK(EQ_EPS_R(pdf, (REAL)0.1, EPS_R), 1);
+ REAL pdf, r;
+ r = RANST_PIECEWISE_LINEAR_GET(pwl, rng);
+ CHK(0 <= r && r <= 10);
+ pdf = RANST_PIECEWISE_LINEAR_PDF(pwl, r);
+ CHK(EQ_EPS_R(pdf, (REAL)0.1, EPS_R) == 1);
x += r;
x2 += r * r;
}
- CHECK(EQ_EPS_R(RANST_PIECEWISE_LINEAR_PDF(pwl, 0), (REAL)0.1, EPS_R), 1);
- CHECK(EQ_EPS_R(RANST_PIECEWISE_LINEAR_PDF(pwl, 10), (REAL)0.1, EPS_R), 1);
- CHECK(RANST_PIECEWISE_LINEAR_PDF(pwl, -1), 0);
- CHECK(RANST_PIECEWISE_LINEAR_PDF(pwl, 11), 0);
+ CHK(EQ_EPS_R(RANST_PIECEWISE_LINEAR_PDF(pwl, 0), (REAL)0.1, EPS_R) == 1);
+ CHK(EQ_EPS_R(RANST_PIECEWISE_LINEAR_PDF(pwl, 10), (REAL)0.1, EPS_R) == 1);
+ CHK(RANST_PIECEWISE_LINEAR_PDF(pwl, -1) == 0);
+ CHK(RANST_PIECEWISE_LINEAR_PDF(pwl, 11) == 0);
mean = x/NBS;
std = SQRT(x2/NBS - mean*mean);
printf("%g %g\n", mean, std);
- CHECK(EQ_EPS_R(mean, exp_mean, (REAL)1e-2), 1);
- CHECK(EQ_EPS_R(std, exp_std, (REAL)1.e-2), 1);
+ CHK(EQ_EPS_R(mean, exp_mean, (REAL)1e-2) == 1);
+ CHK(EQ_EPS_R(std, exp_std, (REAL)1.e-2) == 1);
- CHECK(RANST_PIECEWISE_LINEAR_REF_PUT(pwl), RES_OK);
+ CHK(RANST_PIECEWISE_LINEAR_REF_PUT(pwl) == RES_OK);
- CHECK(ssp_rng_ref_put(rng), RES_OK);
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
}
#undef REAL
diff --git a/src/test_ssp_ran_sphere.h b/src/test_ssp_ran_sphere.h
@@ -55,7 +55,7 @@
#define R3_IS_NORMALIZED f3_is_normalized
#else
-#error "TYPE_SUFFIX must be defined either 0 or 1"
+#error "TYPE_FLOAT must be defined either 0 or 1"
#endif
static void
@@ -69,16 +69,16 @@ TEST()
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssp_rng_create(&allocator, &ssp_rng_mt19937_64, &rng), RES_OK);
+ CHK(ssp_rng_create(&allocator, &ssp_rng_mt19937_64, &rng) == RES_OK);
FOR_EACH(i, 0, NSAMPS) {
f = RAN_SPHERE_UNIFORM(rng, samps[i], &samps[i][3]);
- CHECK(f, samps[i]);
- CHECK(R3_IS_NORMALIZED(f), 1);
- CHECK(EQ_EPS(samps[i][3], 1/(4*(REAL)PI), (REAL)1.e-6), 1);
- CHECK(EQ_EPS(samps[i][3], RAN_SPHERE_UNIFORM_PDF(), (REAL)1.e-6), 1);
+ CHK(f == samps[i]);
+ CHK(R3_IS_NORMALIZED(f) == 1);
+ CHK(EQ_EPS(samps[i][3], 1/(4*(REAL)PI), (REAL)1.e-6) == 1);
+ CHK(EQ_EPS(samps[i][3], RAN_SPHERE_UNIFORM_PDF(), (REAL)1.e-6) == 1);
FOR_EACH(j, 0, i) {
- CHECK(R3_EQ_EPS(samps[j], samps[i], (REAL)1.e-6), 0);
+ CHK(R3_EQ_EPS(samps[j], samps[i], (REAL)1.e-6) == 0);
}
}
@@ -86,7 +86,7 @@ TEST()
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
}
#undef REAL
diff --git a/src/test_ssp_ran_triangle.h b/src/test_ssp_ran_triangle.h
@@ -39,34 +39,35 @@
#endif /* TEST_SSP_RAN_TRIANGLE_H */
#if TYPE_FLOAT==0
-#define REAL double
-#define TEST test_double
-#define RNG_UNIFORM_R ssp_rng_uniform_double
-#define RAN_TRIANGLE_UNIFORM ssp_ran_triangle_uniform
-#define RAN_TRIANGLE_UNIFORM_PDF ssp_ran_triangle_uniform_pdf
-#define EQ_EPS_R eq_eps
-#define R3 d3
-#define R3_DOT d3_dot
-#define R3_SUB d3_sub
-#define R3_MINUS d3_minus
-#define R3_CROSS d3_cross
-#define R3_LEN d3_len
+ #define REAL double
+ #define TEST test_double
+ #define RNG_UNIFORM_R ssp_rng_uniform_double
+ #define RAN_TRIANGLE_UNIFORM ssp_ran_triangle_uniform
+ #define RAN_TRIANGLE_UNIFORM_PDF ssp_ran_triangle_uniform_pdf
+ #define EQ_EPS_R eq_eps
+ #define R3 d3
+ #define R3_DOT d3_dot
+ #define R3_SUB d3_sub
+ #define R3_MINUS d3_minus
+ #define R3_CROSS d3_cross
+ #define R3_LEN d3_len
#elif TYPE_FLOAT==1
-#define REAL float
-#define TEST test_float
-#define RNG_UNIFORM_R ssp_rng_uniform_float
-#define RAN_TRIANGLE_UNIFORM ssp_ran_triangle_uniform_float
-#define RAN_TRIANGLE_UNIFORM_PDF ssp_ran_triangle_uniform_float_pdf
-#define EQ_EPS_R eq_epsf
-#define R3 f3
-#define R3_DOT f3_dot
-#define R3_SUB f3_sub
-#define R3_MINUS f3_minus
-#define R3_CROSS f3_cross
-#define R3_LEN f3_len
+ #define REAL float
+ #define TEST test_float
+ #define RNG_UNIFORM_R ssp_rng_uniform_float
+ #define RAN_TRIANGLE_UNIFORM ssp_ran_triangle_uniform_float
+ #define RAN_TRIANGLE_UNIFORM_PDF ssp_ran_triangle_uniform_float_pdf
+ #define EQ_EPS_R eq_epsf
+ #define R3 f3
+ #define R3_DOT f3_dot
+ #define R3_SUB f3_sub
+ #define R3_MINUS f3_minus
+ #define R3_CROSS f3_cross
+ #define R3_LEN f3_len
+
#else
-#error "TYPE_SUFFIX must be defined either 0 or 1"
+ #error "TYPE_FLOAT must be defined either 0 or 1"
#endif
static void
@@ -85,7 +86,7 @@ TEST()
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssp_rng_create(&allocator, &ssp_rng_mt19937_64, &rng), RES_OK);
+ CHK(ssp_rng_create(&allocator, &ssp_rng_mt19937_64, &rng) == RES_OK);
FOR_EACH(i, 0, 3) {
A[i] = RNG_UNIFORM_R(rng, 0, 1);
@@ -107,21 +108,21 @@ TEST()
REAL dot = 0;
REAL area = 0;
- CHECK(RAN_TRIANGLE_UNIFORM(rng, A, B, C, samps[i], &pdf), samps[i]);
- CHECK(EQ_EPS_R(R3_DOT(plane, samps[i]), -plane[3], (REAL)1.e-6), 1);
+ CHK(RAN_TRIANGLE_UNIFORM(rng, A, B, C, samps[i], &pdf) == samps[i]);
+ CHK(EQ_EPS_R(R3_DOT(plane, samps[i]), -plane[3], (REAL)1.e-6) == 1);
R3_SUB(tmp0, samps[i], A);
dot = R3_DOT(R3_CROSS(tmp0, tmp0, v0), R3_CROSS(tmp1, v1, v0));
- CHECK(sign(dot), 1);
+ CHK(sign(dot) == 1);
R3_SUB(tmp0, samps[i], B);
dot = R3_DOT(R3_CROSS(tmp0, tmp0, v2), R3_CROSS(tmp1, v3, v2));
- CHECK(sign(dot), 1);
+ CHK(sign(dot) == 1);
R3_SUB(tmp0, samps[i], C);
dot = R3_DOT(R3_CROSS(tmp0, tmp0, v4), R3_CROSS(tmp1, v5, v4));
- CHECK(sign(dot), 1);
+ CHK(sign(dot) == 1);
area = R3_LEN(tmp1) * 0.5f;
- CHECK(EQ_EPS_R(1 / area, RAN_TRIANGLE_UNIFORM_PDF(A, B, C), (REAL)1.e-6), 1);
+ CHK(EQ_EPS_R(1 / area, RAN_TRIANGLE_UNIFORM_PDF(A, B, C), (REAL)1.e-6) == 1);
}
nsteps = 10000;
@@ -136,7 +137,7 @@ TEST()
else
counter[1] += 1;
}
- CHECK(labs((long)(counter[1] - counter[0])) < 100, 1);
+ CHK(labs((long)(counter[1] - counter[0])) < 100);
counter[0] = counter[1] = 0;
FOR_EACH(i, 0, nsteps) {
@@ -146,15 +147,14 @@ TEST()
else
counter[1] += 1;
}
- CHECK(labs((long)(counter[1] - counter[0])) < 100, 1);
+ CHK(labs((long)(counter[1] - counter[0])) < 100);
ssp_rng_ref_put(rng);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
}
-
#undef REAL
#undef TEST
#undef RNG_UNIFORM_R
diff --git a/src/test_ssp_ran_uniform_disk.h b/src/test_ssp_ran_uniform_disk.h
@@ -42,30 +42,30 @@
#endif /* TEST_SSP_RAN_UNIFORM_DISK_H */
#if TYPE_FLOAT==0
-#define REAL double
-#define TEST test_double
-#define RNG_UNIFORM_R ssp_rng_uniform_double
-#define RNG_UNIFORM_DISK_LOCAL ssp_ran_uniform_disk_local
-#define RNG_UNIFORM_DISK ssp_ran_uniform_disk
-#define R33_BASIS d33_basis
-#define R33_MULR3 d33_muld3
-#define R3_EQ_EPS d3_eq_eps
-#define R3_NORMALIZE d3_normalize
-#define SQRT sqrt
+ #define REAL double
+ #define TEST test_double
+ #define RNG_UNIFORM_R ssp_rng_uniform_double
+ #define RNG_UNIFORM_DISK_LOCAL ssp_ran_uniform_disk_local
+ #define RNG_UNIFORM_DISK ssp_ran_uniform_disk
+ #define R33_BASIS d33_basis
+ #define R33_MULR3 d33_muld3
+ #define R3_EQ_EPS d3_eq_eps
+ #define R3_NORMALIZE d3_normalize
+ #define SQRT sqrt
#elif TYPE_FLOAT==1
-#define REAL float
-#define TEST test_float
-#define RNG_UNIFORM_R ssp_rng_uniform_float
-#define RNG_UNIFORM_DISK_LOCAL ssp_ran_uniform_disk_float_local
-#define RNG_UNIFORM_DISK ssp_ran_uniform_disk_float
-#define R33_BASIS f33_basis
-#define R33_MULR3 f33_mulf3
-#define R3_EQ_EPS f3_eq_eps
-#define R3_NORMALIZE f3_normalize
-#define SQRT sqrtf
+ #define REAL float
+ #define TEST test_float
+ #define RNG_UNIFORM_R ssp_rng_uniform_float
+ #define RNG_UNIFORM_DISK_LOCAL ssp_ran_uniform_disk_float_local
+ #define RNG_UNIFORM_DISK ssp_ran_uniform_disk_float
+ #define R33_BASIS f33_basis
+ #define R33_MULR3 f33_mulf3
+ #define R3_EQ_EPS f3_eq_eps
+ #define R3_NORMALIZE f3_normalize
+ #define SQRT (float)sqrt
#else
-#error "TYPE_SUFFIX must be defined either 0 or 1"
+ #error "TYPE_FLOAT must be defined either 0 or 1"
#endif
static void
@@ -85,8 +85,8 @@ TEST()
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng0), RES_OK);
- CHECK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng1), RES_OK);
+ CHK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng0) == RES_OK);
+ CHK(ssp_rng_create(&allocator, &ssp_rng_threefry, &rng1) == RES_OK);
up[0] = RNG_UNIFORM_R(rng1, -1, 1);
up[1] = RNG_UNIFORM_R(rng1, -1, 1);
@@ -98,12 +98,12 @@ TEST()
ssp_rng_set(rng1, seed);
memset(counts, 0, sizeof(counts));
- for(i = 0; i < NBS; i++) {
+ FOR_EACH(i, 0, NBS) {
REAL tmp[3];
RNG_UNIFORM_DISK_LOCAL(rng0, 100, pt, NULL);
RNG_UNIFORM_DISK(rng1, 100, up, pt2, NULL);
R33_MULR3(tmp, frame, pt);
- CHECK(R3_EQ_EPS(tmp, pt2, (REAL)1.e-6), 1);
+ CHK(R3_EQ_EPS(tmp, pt2, (REAL)1.e-6) == 1);
ASSERT(pt[2] == 0);
/* locate pt in a 10x10 grid */
r = (int)((100 + pt[0]) / 20);
@@ -111,9 +111,9 @@ TEST()
++counts[r][c];
}
- for(r = 0; r < 10; r++) {
+ FOR_EACH(r, 0, 10) {
int x = (r >= 5 ? r - 4 : r - 5) * 20;
- for(c = 0; c < 10; c++) {
+ FOR_EACH(c, 0, 10) {
int y = (c >= 5 ? c - 4 : c - 5) * 20;
int r2 = x * x + y * y;
if(r2 > 100 * 100)
@@ -128,15 +128,15 @@ TEST()
std = x2_sum / (REAL)nb - mean*mean;
std = std > 0 ? SQRT(std) : 0;
printf("%g %g\n", mean, std);
- CHECK(fabs(mean - exp_mean) < 10, 1);
- CHECK(fabs(std - exp_std) < 200, 1);
+ CHK(fabs(mean - exp_mean) < 10);
+ CHK(fabs(std - exp_std) < 200);
- CHECK(ssp_rng_ref_put(rng0), RES_OK);
- CHECK(ssp_rng_ref_put(rng1), RES_OK);
+ CHK(ssp_rng_ref_put(rng0) == RES_OK);
+ CHK(ssp_rng_ref_put(rng1) == RES_OK);
check_memory_allocator(&allocator);
mem_shutdown_proxy_allocator(&allocator);
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
}
#undef REAL
diff --git a/src/test_ssp_rng.c b/src/test_ssp_rng.c
@@ -61,13 +61,13 @@ test_rng(const struct ssp_rng_type* type)
mem_init_proxy_allocator(&allocator, &mem_default_allocator);
- NCHECK(type, NULL);
- CHECK(ssp_rng_create(NULL, NULL, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_create(&allocator, NULL, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_create(NULL, type, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_create(&allocator, type, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_create(NULL, NULL, &rng), RES_BAD_ARG);
- CHECK(ssp_rng_create(&allocator, NULL, &rng), RES_BAD_ARG);
+ CHK(type != NULL);
+ CHK(ssp_rng_create(NULL, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_create(&allocator, NULL, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_create(NULL, type, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_create(&allocator, type, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_create(NULL, NULL, &rng) == RES_BAD_ARG);
+ CHK(ssp_rng_create(&allocator, NULL, &rng) == RES_BAD_ARG);
r = ssp_rng_create(NULL, type, &rng);
#ifdef WITH_R123_AES
if (r == RES_BAD_OP && type == &ssp_rng_aes) {
@@ -77,97 +77,97 @@ test_rng(const struct ssp_rng_type* type)
return;
}
#endif
- CHECK(r, RES_OK);
-
- CHECK(ssp_rng_get_type(NULL, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_get_type(rng, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_get_type(NULL, &type2), RES_BAD_ARG);
- CHECK(ssp_rng_get_type(rng, &type2), RES_OK);
- CHECK(ssp_rng_type_eq(type, &type2), 1);
-
- CHECK(ssp_rng_ref_get(NULL), RES_BAD_ARG);
- CHECK(ssp_rng_ref_get(rng), RES_OK);
- CHECK(ssp_rng_ref_put(NULL), RES_BAD_ARG);
- CHECK(ssp_rng_ref_put(rng), RES_OK);
- CHECK(ssp_rng_ref_put(rng), RES_OK);
-
- CHECK(ssp_rng_create(&allocator, type, &rng), RES_OK);
- CHECK(ssp_rng_set(NULL, 0), RES_BAD_ARG);
- CHECK(ssp_rng_set(rng, 0), can_set ? RES_OK : RES_BAD_OP);
-
- CHECK(ssp_rng_create(NULL, type, &rng1), RES_OK);
- CHECK(ssp_rng_create(NULL, type, &rng2), RES_OK);
- CHECK(ssp_rng_discard(rng1, 10), can_discard ? RES_OK : RES_BAD_OP);
+ CHK(r == RES_OK);
+
+ CHK(ssp_rng_get_type(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_get_type(rng, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_get_type(NULL, &type2) == RES_BAD_ARG);
+ CHK(ssp_rng_get_type(rng, &type2) == RES_OK);
+ CHK(ssp_rng_type_eq(type, &type2) == 1);
+
+ CHK(ssp_rng_ref_get(NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_ref_get(rng) == RES_OK);
+ CHK(ssp_rng_ref_put(NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
+
+ CHK(ssp_rng_create(&allocator, type, &rng) == RES_OK);
+ CHK(ssp_rng_set(NULL, 0) == RES_BAD_ARG);
+ CHK(ssp_rng_set(rng, 0) == (can_set ? RES_OK : RES_BAD_OP));
+
+ CHK(ssp_rng_create(NULL, type, &rng1) == RES_OK);
+ CHK(ssp_rng_create(NULL, type, &rng2) == RES_OK);
+ CHK(ssp_rng_discard(rng1, 10) == (can_discard ? RES_OK : RES_BAD_OP));
if (type != &ssp_rng_random_device) {
for (i = 0; i < 10; i++) ssp_rng_get(rng2);
- CHECK(ssp_rng_get(rng1), ssp_rng_get(rng2));
+ CHK(ssp_rng_get(rng1) == ssp_rng_get(rng2));
}
FOR_EACH(i, 0, NRAND) {
datai0[i] = ssp_rng_get(rng);
- CHECK(datai0[i] >= ssp_rng_min(rng), 1);
- CHECK(datai0[i] <= ssp_rng_max(rng), 1);
+ CHK(datai0[i] >= ssp_rng_min(rng));
+ CHK(datai0[i] <= ssp_rng_max(rng));
FOR_EACH(j, 0, i) {
- NCHECK(datai0[i], datai0[j]);
+ CHK(datai0[i] != datai0[j]);
}
}
- CHECK(ssp_rng_set(rng, 0xDECAFBAD), can_set ? RES_OK : RES_BAD_OP);
+ CHK(ssp_rng_set(rng, 0xDECAFBAD) == (can_set ? RES_OK : RES_BAD_OP));
FOR_EACH(i, 0, NRAND) {
datai1[i] = ssp_rng_get(rng);
- NCHECK(datai1[i], datai0[i]);
- CHECK(datai1[i] >= ssp_rng_min(rng), 1);
- CHECK(datai1[i] <= ssp_rng_max(rng), 1);
+ CHK(datai1[i] != datai0[i]);
+ CHK(datai1[i] >= ssp_rng_min(rng));
+ CHK(datai1[i] <= ssp_rng_max(rng));
FOR_EACH(j, 0, i) {
- NCHECK(datai1[i], datai1[j]);
+ CHK(datai1[i] != datai1[j]);
}
}
FOR_EACH(i, 0, NRAND) {
datai0[i] = ssp_rng_uniform_uint64(rng, 1, 79);
- CHECK(datai0[i] >= 1, 1);
- CHECK(datai0[i] <= 79, 1);
+ CHK(datai0[i] >= 1);
+ CHK(datai0[i] <= 79);
}
FOR_EACH(i, 0, NRAND) {
FOR_EACH(j, 0, NRAND) if(datai0[i] != datai0[j]) break;
- NCHECK(j, NRAND);
+ CHK(j != NRAND);
}
FOR_EACH(i, 0, NRAND) {
datad[i] = ssp_rng_uniform_double(rng, -5.0, 11.3);
- CHECK(datad[i] >= -5.0, 1);
- CHECK(datad[i] <= 11.3, 1);
+ CHK(datad[i] >= -5.0);
+ CHK(datad[i] <= 11.3);
}
FOR_EACH(i, 0, NRAND) {
FOR_EACH(j, 0, NRAND) if(datad[i] != datad[j]) break;
- NCHECK(j, NRAND);
+ CHK(j != NRAND);
}
FOR_EACH(i, 0, NRAND) {
dataf[i] = ssp_rng_uniform_float(rng, -1.0, 12.5);
- CHECK(dataf[i] >= -1.0, 1);
- CHECK(dataf[i] <= 12.5, 1);
+ CHK(dataf[i] >= -1.0);
+ CHK(dataf[i] <= 12.5);
}
FOR_EACH(i, 0, NRAND) {
FOR_EACH(j, 0, NRAND) if(dataf[i] != dataf[j]) break;
- NCHECK(j, NRAND);
+ CHK(j != NRAND);
}
FOR_EACH(i, 0, NRAND) {
datad[i] = ssp_rng_canonical(rng);
- CHECK(datad[i] >= 0.0, 1);
- CHECK(datad[i] < 1.0, 1);
+ CHK(datad[i] >= 0.0);
+ CHK(datad[i] < 1.0 );
FOR_EACH(j, 0, i) {
- NCHECK(datad[i], datad[j]);
+ CHK(datad[i] != datad[j]);
}
}
FOR_EACH(i, 0, NRAND) {
dataf[i] = ssp_rng_canonical_float(rng);
- CHECK(dataf[i] >= 0.0, 1);
- CHECK(dataf[i] < 1.0, 1);
+ CHK(dataf[i] >= 0.0);
+ CHK(dataf[i] < 1.0);
FOR_EACH(j, 0, i) {
- NCHECK(dataf[i], dataf[j]);
+ CHK(dataf[i] != dataf[j]);
}
}
@@ -186,31 +186,31 @@ test_rng(const struct ssp_rng_type* type)
}
stream = tmpfile();
- NCHECK(stream, NULL);
- CHECK(ssp_rng_write(NULL, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_write(rng, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_write(NULL, stream), RES_BAD_ARG);
- CHECK(ssp_rng_write(rng, stream), can_rw ? RES_OK : RES_BAD_OP);
+ CHK(stream != NULL);
+ CHK(ssp_rng_write(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_write(rng, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_write(NULL, stream) == RES_BAD_ARG);
+ CHK(ssp_rng_write(rng, stream) == (can_rw ? RES_OK : RES_BAD_OP));
FOR_EACH(i, 0, NRAND)
datai0[i] = ssp_rng_get(rng);
- CHECK(ssp_rng_read(NULL, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_read(rng, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_read(NULL, stream), RES_BAD_ARG);
- CHECK(ssp_rng_read(rng, stream), can_rw ? RES_IO_ERR : RES_BAD_OP);
+ CHK(ssp_rng_read(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_read(rng, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_read(NULL, stream) == RES_BAD_ARG);
+ CHK(ssp_rng_read(rng, stream) == (can_rw ? RES_IO_ERR : RES_BAD_OP));
rewind(stream);
- CHECK(ssp_rng_read(rng, stream), can_rw ? RES_OK : RES_BAD_OP);
+ CHK(ssp_rng_read(rng, stream) == (can_rw ? RES_OK : RES_BAD_OP));
if (can_rw) {
FOR_EACH(i, 0, NRAND) {
uint64_t rn = ssp_rng_get(rng);
- CHECK(rn, datai0[i]);
+ CHK(rn == datai0[i]);
}
}
fclose(stream);
- CHECK(ssp_rng_ref_put(rng), RES_OK);
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
ssp_rng_ref_put(rng1);
ssp_rng_ref_put(rng2);
@@ -248,7 +248,7 @@ main(int argc, char** argv)
ASSERT(0);
}
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
diff --git a/src/test_ssp_rng_proxy.c b/src/test_ssp_rng_proxy.c
@@ -40,34 +40,86 @@ test_creation(void)
struct ssp_rng_proxy* proxy;
struct ssp_rng_type type;
- CHECK(ssp_rng_proxy_create(NULL, NULL, 0, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_create(NULL, &ssp_rng_mt19937_64, 0, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_create(NULL, NULL, 4, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_create(NULL, &ssp_rng_mt19937_64, 4, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_create(NULL, NULL, 0, &proxy), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_create(NULL, &ssp_rng_mt19937_64, 0, &proxy), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_create(NULL, NULL, 4, &proxy), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_create(NULL, &ssp_rng_mt19937_64, 4, &proxy), RES_OK);
-
- CHECK(ssp_rng_proxy_get_type(NULL, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_get_type(proxy, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_get_type(NULL, &type), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_get_type(proxy, &type), RES_OK);
-
- CHECK(ssp_rng_type_eq(&type, &ssp_rng_kiss), 0);
- CHECK(ssp_rng_type_eq(&type, &ssp_rng_mt19937_64), 1);
-
- CHECK(ssp_rng_proxy_ref_get(NULL), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_ref_get(proxy), RES_OK);
- CHECK(ssp_rng_proxy_ref_put(NULL), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_ref_put(proxy), RES_OK);
- CHECK(ssp_rng_proxy_ref_put(proxy), RES_OK);
-
- CHECK(ssp_rng_proxy_create
- (&mem_default_allocator, &ssp_rng_threefry, 1, &proxy), RES_OK);
- CHECK(ssp_rng_proxy_get_type(proxy, &type), RES_OK);
- CHECK(ssp_rng_type_eq(&type, &ssp_rng_threefry), 1);
- CHECK(ssp_rng_proxy_ref_put(proxy), RES_OK);
+ CHK(ssp_rng_proxy_create(NULL, NULL, 0, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create(NULL, &ssp_rng_mt19937_64, 0, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create(NULL, NULL, 4, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create(NULL, &ssp_rng_mt19937_64, 4, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create(NULL, NULL, 0, &proxy) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create(NULL, &ssp_rng_mt19937_64, 0, &proxy) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create(NULL, NULL, 4, &proxy) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create(NULL, &ssp_rng_mt19937_64, 4, &proxy) == RES_OK);
+
+ CHK(ssp_rng_proxy_get_type(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_get_type(proxy, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_get_type(NULL, &type) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_get_type(proxy, &type) == RES_OK);
+
+ CHK(ssp_rng_type_eq(&type, &ssp_rng_kiss) == 0);
+ CHK(ssp_rng_type_eq(&type, &ssp_rng_mt19937_64) == 1);
+
+ CHK(ssp_rng_proxy_ref_get(NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_ref_get(proxy) == RES_OK);
+ CHK(ssp_rng_proxy_ref_put(NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_ref_put(proxy) == RES_OK);
+ CHK(ssp_rng_proxy_ref_put(proxy) == RES_OK);
+
+ CHK(ssp_rng_proxy_create
+ (&mem_default_allocator, &ssp_rng_threefry, 1, &proxy) == RES_OK);
+ CHK(ssp_rng_proxy_get_type(proxy, &type) == RES_OK);
+ CHK(ssp_rng_type_eq(&type, &ssp_rng_threefry) == 1);
+ CHK(ssp_rng_proxy_ref_put(proxy) == RES_OK);
+}
+
+static void
+test_creation2(void)
+{
+ const struct ssp_rng_type* type = &ssp_rng_mt19937_64;
+ struct ssp_rng_proxy* proxy;
+
+ CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 0, 0, 0, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, type, 0, 0, 0, 0, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 32, 0, 0, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, type, 0, 32, 0, 0, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 0, 32, 0, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, type, 0, 0, 32, 0, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 32, 32, 0, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, type, 0, 32, 32, 0, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 0, 0, 1, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, type, 0, 0, 0, 1, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 32, 0, 1, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, type, 0, 32, 0, 1, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 0, 32, 1, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, type, 0, 0, 32, 1, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 32, 32, 1, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, type, 0, 32, 32, 1, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 0, 0, 0, &proxy) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, type, 0, 0, 0, 0, &proxy) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 32, 0, 0, &proxy) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, type, 0, 32, 0, 0, &proxy) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 0, 32, 0, &proxy) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, type, 0, 0, 32, 0, &proxy) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 32, 32, 0, &proxy) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, type, 0, 32, 32, 0, &proxy) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 0, 0, 1, &proxy) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, type, 0, 0, 0, 1, &proxy) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 32, 0, 1, &proxy) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, type, 0, 32, 0, 1, &proxy) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 0, 32, 1, &proxy) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, type, 0, 0, 32, 1, &proxy) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, NULL, 0, 32, 32, 1, &proxy) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2(NULL, type, 0, 32, 32, 1, &proxy) == RES_OK);
+ CHK(ssp_rng_proxy_ref_put(proxy) == RES_OK);
+
+ CHK(ssp_rng_proxy_create2(NULL, type, 0, 32, 32, 4, &proxy) == RES_OK);
+ CHK(ssp_rng_proxy_ref_put(proxy) == RES_OK);
+
+ CHK(ssp_rng_proxy_create2(NULL, type, 0, 32, 32, 32, &proxy) == RES_OK);
+ CHK(ssp_rng_proxy_ref_put(proxy) == RES_OK);
+
+ CHK(ssp_rng_proxy_create2(NULL, type, 0, 32, 32, 33, &proxy) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create2
+ (&mem_default_allocator, type, 1024, 32, 32, 4, &proxy) == RES_OK);
+ CHK(ssp_rng_proxy_ref_put(proxy) == RES_OK);
}
static void
@@ -79,35 +131,127 @@ test_rng_from_proxy(void)
uint64_t r[4];
size_t i, j, k;
- CHECK(ssp_rng_proxy_create(NULL, &ssp_rng_mt19937_64, 4, &proxy), RES_OK);
+ CHK(ssp_rng_proxy_create(NULL, &ssp_rng_mt19937_64, 4, &proxy) == RES_OK);
- CHECK(ssp_rng_proxy_create_rng(NULL, 0, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_create_rng(proxy, 0, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_create_rng(NULL, 0, &rng[0]), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_create_rng(proxy, 0, &rng[0]), RES_OK);
- CHECK(ssp_rng_proxy_create_rng(proxy, 0, &rng[1]), RES_BAD_ARG);
- CHECK(ssp_rng_ref_put(rng[0]), RES_OK);
+ CHK(ssp_rng_proxy_create_rng(NULL, 0, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create_rng(proxy, 0, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create_rng(NULL, 0, &rng[0]) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create_rng(proxy, 0, &rng[0]) == RES_OK);
+ CHK(ssp_rng_proxy_create_rng(proxy, 0, &rng[1]) == RES_BAD_ARG);
+ CHK(ssp_rng_ref_put(rng[0]) == RES_OK);
- CHECK(ssp_rng_proxy_create_rng(proxy, 4, &rng[0]), RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create_rng(proxy, 4, &rng[0]) == RES_BAD_ARG);
- FOR_EACH(i, 0, 4) CHECK(ssp_rng_proxy_create_rng(proxy, i, &rng[i]), RES_OK);
- CHECK(ssp_rng_proxy_ref_put(proxy), RES_OK);
+ FOR_EACH(i, 0, 4) CHK(ssp_rng_proxy_create_rng(proxy, i, &rng[i]) == RES_OK);
+ CHK(ssp_rng_proxy_ref_put(proxy) == RES_OK);
- CHECK(ssp_rng_get_type(rng[0], &type), RES_OK);
+ CHK(ssp_rng_get_type(rng[0], &type) == RES_OK);
FOR_EACH(i, 1, 4) {
struct ssp_rng_type type2;
- CHECK(ssp_rng_get_type(rng[i], &type2), RES_OK);
- CHECK(ssp_rng_type_eq(&type, &type2), 1);
+ CHK(ssp_rng_get_type(rng[i], &type2) == RES_OK);
+ CHK(ssp_rng_type_eq(&type, &type2) == 1);
}
FOR_EACH(i, 0, NRANDS) {
FOR_EACH(j, 0, 4) {
r[j] = ssp_rng_get(rng[j]);
- FOR_EACH(k, 0, j) NCHECK(r[k], r[j]);
+ FOR_EACH(k, 0, j) CHK(r[k] != r[j]);
+ }
+ }
+
+ FOR_EACH(i, 0, 4) CHK(ssp_rng_ref_put(rng[i]) == RES_OK);
+}
+
+static void
+test_rng_from_proxy2(void)
+{
+ struct ssp_rng_proxy* proxy[2];
+ struct ssp_rng* rng[4];
+ const size_t block_sz = 99;
+ const size_t nrands = 1000;
+ uint64_t* r[4];
+ size_t i, j;
+
+ CHK((r[0] = mem_alloc(sizeof(uint64_t)*nrands)) != NULL);
+ CHK((r[1] = mem_alloc(sizeof(uint64_t)*nrands)) != NULL);
+ CHK((r[2] = mem_alloc(sizeof(uint64_t)*nrands)) != NULL);
+ CHK((r[3] = mem_alloc(sizeof(uint64_t)*nrands)) != NULL);
+
+ CHK(ssp_rng_proxy_create2
+ (NULL, &ssp_rng_mt19937_64, 0, block_sz, block_sz, 4, &proxy[0]) == RES_OK);
+
+ CHK(ssp_rng_proxy_create_rng(proxy[0], 0, &rng[0]) == RES_OK);
+ CHK(ssp_rng_proxy_create_rng(proxy[0], 1, &rng[1]) == RES_OK);
+ CHK(ssp_rng_proxy_create_rng(proxy[0], 2, &rng[2]) == RES_OK);
+ CHK(ssp_rng_proxy_create_rng(proxy[0], 3, &rng[3]) == RES_OK);
+
+ /* Generate random numbers */
+ FOR_EACH(i, 0, nrands) {
+ r[0][i] = ssp_rng_get(rng[0]);
+ r[1][i] = ssp_rng_get(rng[1]);
+ r[2][i] = ssp_rng_get(rng[2]);
+ r[3][i] = ssp_rng_get(rng[3]);
+ }
+
+ /* Check that each RNG generate a unique sequence of random numbers */
+ FOR_EACH(i, 0, nrands) {
+ FOR_EACH(j, 0, nrands) {
+ CHK(r[0][i] != r[1][j]);
+ CHK(r[0][i] != r[2][j]);
+ CHK(r[0][i] != r[3][j]);
+ CHK(r[1][i] != r[2][j]);
+ CHK(r[1][i] != r[3][j]);
+ CHK(r[2][i] != r[3][j]);
+ }
+ }
+
+ CHK(ssp_rng_proxy_ref_put(proxy[0]) == RES_OK);
+ CHK(ssp_rng_ref_put(rng[0]) == RES_OK);
+ CHK(ssp_rng_ref_put(rng[1]) == RES_OK);
+ CHK(ssp_rng_ref_put(rng[2]) == RES_OK);
+ CHK(ssp_rng_ref_put(rng[3]) == RES_OK);
+
+ CHK(ssp_rng_proxy_create2(NULL, &ssp_rng_mt19937_64,
+ 0, block_sz, 2*block_sz, 2, &proxy[0]) == RES_OK);
+ CHK(ssp_rng_proxy_create2(NULL, &ssp_rng_mt19937_64,
+ block_sz, block_sz, 2*block_sz, 2, &proxy[1]) == RES_OK);
+
+ CHK(ssp_rng_proxy_create_rng(proxy[0], 0, &rng[0]) == RES_OK);
+ CHK(ssp_rng_proxy_create_rng(proxy[0], 1, &rng[1]) == RES_OK);
+ CHK(ssp_rng_proxy_create_rng(proxy[1], 0, &rng[2]) == RES_OK);
+ CHK(ssp_rng_proxy_create_rng(proxy[1], 1, &rng[3]) == RES_OK);
+
+ /* Generate random numbers */
+ FOR_EACH(i, 0, nrands) {
+ r[0][i] = ssp_rng_get(rng[0]);
+ r[1][i] = ssp_rng_get(rng[1]);
+ r[2][i] = ssp_rng_get(rng[2]);
+ r[3][i] = ssp_rng_get(rng[3]);
+ }
+
+ /* Check that each RNG generate a unique sequence of random numbers */
+ FOR_EACH(i, 0, nrands) {
+ FOR_EACH(j, 0, nrands) {
+ CHK(r[0][i] != r[1][j]);
+ CHK(r[0][i] != r[2][j]);
+ CHK(r[0][i] != r[3][j]);
+ CHK(r[1][i] != r[2][j]);
+ CHK(r[1][i] != r[3][j]);
+ CHK(r[2][i] != r[3][j]);
}
}
- FOR_EACH(i, 0, 4) CHECK(ssp_rng_ref_put(rng[i]), RES_OK);
+ CHK(ssp_rng_proxy_ref_put(proxy[0]) == RES_OK);
+ CHK(ssp_rng_proxy_ref_put(proxy[1]) == RES_OK);
+ CHK(ssp_rng_ref_put(rng[0]) == RES_OK);
+ CHK(ssp_rng_ref_put(rng[1]) == RES_OK);
+ CHK(ssp_rng_ref_put(rng[2]) == RES_OK);
+ CHK(ssp_rng_ref_put(rng[3]) == RES_OK);
+
+ mem_rm(r[0]);
+ mem_rm(r[1]);
+ mem_rm(r[2]);
+ mem_rm(r[3]);
}
static void
@@ -120,26 +264,26 @@ test_multi_proxies(void)
struct ssp_rng* rng3;
size_t i;
- CHECK(ssp_rng_proxy_create(NULL, &ssp_rng_threefry, 1, &proxy1), RES_OK);
- CHECK(ssp_rng_proxy_create(NULL, &ssp_rng_threefry, 1, &proxy2), RES_OK);
+ CHK(ssp_rng_proxy_create(NULL, &ssp_rng_threefry, 1, &proxy1) == RES_OK);
+ CHK(ssp_rng_proxy_create(NULL, &ssp_rng_threefry, 1, &proxy2) == RES_OK);
- CHECK(ssp_rng_proxy_create_rng(proxy1, 0, &rng1), RES_OK);
- CHECK(ssp_rng_proxy_create_rng(proxy2, 0, &rng2), RES_OK);
+ CHK(ssp_rng_proxy_create_rng(proxy1, 0, &rng1) == RES_OK);
+ CHK(ssp_rng_proxy_create_rng(proxy2, 0, &rng2) == RES_OK);
ssp_rng_create(NULL, &ssp_rng_threefry, &rng3);
- CHECK(ssp_rng_proxy_ref_put(proxy1), RES_OK);
- CHECK(ssp_rng_proxy_ref_put(proxy2), RES_OK);
+ CHK(ssp_rng_proxy_ref_put(proxy1) == RES_OK);
+ CHK(ssp_rng_proxy_ref_put(proxy2) == RES_OK);
ssp_rng_discard(rng1, COUNT);
ssp_rng_discard(rng3, COUNT+1);
FOR_EACH(i, 0, COUNT) ssp_rng_get(rng2);
- CHECK(ssp_rng_get(rng1), ssp_rng_get(rng2));
- CHECK(ssp_rng_get(rng1), ssp_rng_get(rng3));
+ CHK(ssp_rng_get(rng1) == ssp_rng_get(rng2));
+ CHK(ssp_rng_get(rng1) == ssp_rng_get(rng3));
- CHECK(ssp_rng_ref_put(rng1), RES_OK);
- CHECK(ssp_rng_ref_put(rng2), RES_OK);
- CHECK(ssp_rng_ref_put(rng3), RES_OK);
+ CHK(ssp_rng_ref_put(rng1) == RES_OK);
+ CHK(ssp_rng_ref_put(rng2) == RES_OK);
+ CHK(ssp_rng_ref_put(rng3) == RES_OK);
}
static void
@@ -151,45 +295,45 @@ test_proxy_from_rng(void)
uint64_t r[4];
size_t i, j, k;
- CHECK(ssp_rng_create(NULL, &ssp_rng_threefry, &rng[0]), RES_OK);
- CHECK(ssp_rng_discard(rng[0], COUNT), RES_OK);
+ CHK(ssp_rng_create(NULL, &ssp_rng_threefry, &rng[0]) == RES_OK);
+ CHK(ssp_rng_discard(rng[0], COUNT) == RES_OK);
- CHECK(ssp_rng_proxy_create_from_rng(NULL, NULL, 0, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_create_from_rng(NULL, rng[0], 0, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_create_from_rng(NULL, NULL, 1, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_create_from_rng(NULL, rng[0], 1, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_create_from_rng(NULL, NULL, 0, &proxy), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_create_from_rng(NULL, rng[0], 0, &proxy), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_create_from_rng(NULL, NULL, 1, &proxy), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_create_from_rng(NULL, rng[0], 1, &proxy), RES_OK);
- CHECK(ssp_rng_proxy_create_rng(proxy, 0, &rng[1]), RES_OK);
- CHECK(ssp_rng_proxy_create_rng(proxy, 0, &rng[2]), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_create_rng(proxy, 1, &rng[2]), RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create_from_rng(NULL, NULL, 0, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create_from_rng(NULL, rng[0], 0, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create_from_rng(NULL, NULL, 1, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create_from_rng(NULL, rng[0], 1, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create_from_rng(NULL, NULL, 0, &proxy) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create_from_rng(NULL, rng[0], 0, &proxy) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create_from_rng(NULL, NULL, 1, &proxy) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create_from_rng(NULL, rng[0], 1, &proxy) == RES_OK);
+ CHK(ssp_rng_proxy_create_rng(proxy, 0, &rng[1]) == RES_OK);
+ CHK(ssp_rng_proxy_create_rng(proxy, 0, &rng[2]) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_create_rng(proxy, 1, &rng[2]) == RES_BAD_ARG);
- CHECK(ssp_rng_get(rng[0]), ssp_rng_get(rng[1]));
+ CHK(ssp_rng_get(rng[0]) == ssp_rng_get(rng[1]));
- CHECK(ssp_rng_ref_put(rng[1]), RES_OK);
- CHECK(ssp_rng_proxy_ref_put(proxy), RES_OK);
+ CHK(ssp_rng_ref_put(rng[1]) == RES_OK);
+ CHK(ssp_rng_proxy_ref_put(proxy) == RES_OK);
- CHECK(ssp_rng_proxy_create_from_rng(NULL, rng[0], 4, &proxy), RES_OK);
- CHECK(ssp_rng_ref_put(rng[0]), RES_OK);
- FOR_EACH(i, 0, 4) CHECK(ssp_rng_proxy_create_rng(proxy, i, &rng[i]), RES_OK);
- CHECK(ssp_rng_proxy_ref_put(proxy), RES_OK);
+ CHK(ssp_rng_proxy_create_from_rng(NULL, rng[0], 4, &proxy) == RES_OK);
+ CHK(ssp_rng_ref_put(rng[0]) == RES_OK);
+ FOR_EACH(i, 0, 4) CHK(ssp_rng_proxy_create_rng(proxy, i, &rng[i]) == RES_OK);
+ CHK(ssp_rng_proxy_ref_put(proxy) == RES_OK);
- CHECK(ssp_rng_get_type(rng[0], &type), RES_OK);
+ CHK(ssp_rng_get_type(rng[0], &type) == RES_OK);
FOR_EACH(i, 1, 4) {
struct ssp_rng_type type2;
- CHECK(ssp_rng_get_type(rng[i], &type2), RES_OK);
- CHECK(ssp_rng_type_eq(&type, &type2), 1);
+ CHK(ssp_rng_get_type(rng[i], &type2) == RES_OK);
+ CHK(ssp_rng_type_eq(&type, &type2) == 1);
}
FOR_EACH(i, 0, NRANDS) {
FOR_EACH(j, 0, 4) {
r[j] = ssp_rng_get(rng[j]);
- FOR_EACH(k, 0, j) NCHECK(r[k], r[j]);
+ FOR_EACH(k, 0, j) CHK(r[k] != r[j]);
}
}
- FOR_EACH(i, 0, 4) CHECK(ssp_rng_ref_put(rng[i]), RES_OK);
+ FOR_EACH(i, 0, 4) CHK(ssp_rng_ref_put(rng[i]) == RES_OK);
}
static void
@@ -202,38 +346,38 @@ test_read(void)
uint64_t r[4];
size_t i, j, k;
- CHECK(ssp_rng_create(NULL, &ssp_rng_mt19937_64, &rng), RES_OK);
- CHECK(ssp_rng_discard(rng, COUNT), RES_OK);
+ CHK(ssp_rng_create(NULL, &ssp_rng_mt19937_64, &rng) == RES_OK);
+ CHK(ssp_rng_discard(rng, COUNT) == RES_OK);
stream = tmpfile();
- NCHECK(stream, NULL);
- CHECK(ssp_rng_write(rng, stream), RES_OK);
+ CHK(stream != NULL);
+ CHK(ssp_rng_write(rng, stream) == RES_OK);
rewind(stream);
- CHECK(ssp_rng_proxy_create(NULL, &ssp_rng_mt19937_64, 4, &proxy), RES_OK);
- CHECK(ssp_rng_proxy_read(NULL, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_read(proxy, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_read(NULL, stream), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_read(proxy, stream), RES_OK);
+ CHK(ssp_rng_proxy_create(NULL, &ssp_rng_mt19937_64, 4, &proxy) == RES_OK);
+ CHK(ssp_rng_proxy_read(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_read(proxy, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_read(NULL, stream) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_read(proxy, stream) == RES_OK);
- FOR_EACH(i, 0, 4) CHECK(ssp_rng_proxy_create_rng(proxy, i, &rng1[i]), RES_OK);
+ FOR_EACH(i, 0, 4) CHK(ssp_rng_proxy_create_rng(proxy, i, &rng1[i]) == RES_OK);
r[0] = ssp_rng_get(rng);
- CHECK(r[0], ssp_rng_get(rng1[0]));
- NCHECK(r[0], ssp_rng_get(rng1[1]));
- NCHECK(r[0], ssp_rng_get(rng1[2]));
- NCHECK(r[0], ssp_rng_get(rng1[3]));
+ CHK(r[0] == ssp_rng_get(rng1[0]));
+ CHK(r[0] != ssp_rng_get(rng1[1]));
+ CHK(r[0] != ssp_rng_get(rng1[2]));
+ CHK(r[0] != ssp_rng_get(rng1[3]));
FOR_EACH(i, 0, NRANDS) {
FOR_EACH(j, 0, 4) {
r[j] = ssp_rng_get(rng1[j]);
- FOR_EACH(k, 0, j) NCHECK(r[k], r[j]);
+ FOR_EACH(k, 0, j) CHK(r[k] != r[j]);
}
}
- CHECK(ssp_rng_proxy_ref_put(proxy), RES_OK);
- CHECK(ssp_rng_ref_put(rng), RES_OK);
- FOR_EACH(i, 0, 4) CHECK(ssp_rng_ref_put(rng1[i]), RES_OK);
+ CHK(ssp_rng_proxy_ref_put(proxy) == RES_OK);
+ CHK(ssp_rng_ref_put(rng) == RES_OK);
+ FOR_EACH(i, 0, 4) CHK(ssp_rng_ref_put(rng1[i]) == RES_OK);
fclose(stream);
}
@@ -247,28 +391,28 @@ test_write(void)
uint64_t r;
stream = tmpfile();
- NCHECK(stream, NULL);
+ CHK(stream != NULL);
- CHECK(ssp_rng_proxy_create(NULL, &ssp_rng_ranlux48, 1, &proxy), RES_OK);
- CHECK(ssp_rng_proxy_create_rng(proxy, 0, &rng0), RES_OK);
+ CHK(ssp_rng_proxy_create(NULL, &ssp_rng_ranlux48, 1, &proxy) == RES_OK);
+ CHK(ssp_rng_proxy_create_rng(proxy, 0, &rng0) == RES_OK);
- CHECK(ssp_rng_proxy_write(NULL, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_write(proxy, NULL), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_write(NULL, stream), RES_BAD_ARG);
- CHECK(ssp_rng_proxy_write(proxy, stream), RES_OK);
+ CHK(ssp_rng_proxy_write(NULL, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_write(proxy, NULL) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_write(NULL, stream) == RES_BAD_ARG);
+ CHK(ssp_rng_proxy_write(proxy, stream) == RES_OK);
- CHECK(ssp_rng_create(NULL, &ssp_rng_ranlux48, &rng1), RES_OK);
+ CHK(ssp_rng_create(NULL, &ssp_rng_ranlux48, &rng1) == RES_OK);
r = ssp_rng_get(rng0);
- CHECK(r, ssp_rng_get(rng1));
+ CHK(r == ssp_rng_get(rng1));
rewind(stream);
- CHECK(ssp_rng_read(rng1, stream), RES_OK);
- CHECK(r, ssp_rng_get(rng1));
- CHECK(ssp_rng_get(rng0), ssp_rng_get(rng1));
+ CHK(ssp_rng_read(rng1, stream) == RES_OK);
+ CHK(r == ssp_rng_get(rng1));
+ CHK(ssp_rng_get(rng0) == ssp_rng_get(rng1));
- CHECK(ssp_rng_proxy_ref_put(proxy), RES_OK);
- CHECK(ssp_rng_ref_put(rng0), RES_OK);
- CHECK(ssp_rng_ref_put(rng1), RES_OK);
+ CHK(ssp_rng_proxy_ref_put(proxy) == RES_OK);
+ CHK(ssp_rng_ref_put(rng0) == RES_OK);
+ CHK(ssp_rng_ref_put(rng1) == RES_OK);
fclose(stream);
}
@@ -278,11 +422,13 @@ main(int argc, char** argv)
{
(void)argc, (void)argv;
test_creation();
+ test_creation2();
test_rng_from_proxy();
+ test_rng_from_proxy2();
test_multi_proxies();
test_proxy_from_rng();
test_read();
test_write();
- CHECK(mem_allocated_size(), 0);
+ CHK(mem_allocated_size() == 0);
return 0;
}
