static int test_item3(void)
{
int rc = 0;
int val = 0;
val = random_value(10, 100);
if (PMI_SUCCESS != (rc = PMI_KVS_Get_key_length_max(&val))) {
log_fatal("PMI_KVS_Get_key_length_max failed: %d\n", rc);
return rc;
}
log_info("PMI_KVS_Get_key_length_max=%d\n", val);
if (!_legacy) {
log_assert(511 == val, "Check PMIX_MAX_KEYLEN value in pmix_common.h");
}
val = random_value(10, 100);
if (PMI_SUCCESS != (rc = PMI_KVS_Get_value_length_max(&val))) {
log_fatal("PMI_KVS_Get_value_length_max failed: %d\n", rc);
return rc;
}
log_info("PMI_KVS_Get_value_length_max=%d\n", val);
if (!_legacy) {
log_assert(4096 == val, "Check limitation for a value");
}
return rc;
}
void run_cblas_test(const typed_parameters& p)
{
// input data
test_vector<value_type> x(p.n, p.incx);
test_vector<value_type> y(p.n, p.incy);
// generate data
randomize(x);
randomize(y);
value_type s = random_value(value_type(-1), value_type(1));
value_type c = random_value(value_type(-1), value_type(1));
// ampblas data
ampblas_test_vector<value_type> x_amp(x);
ampblas_test_vector<value_type> y_amp(y);
// test references
start_reference_test();
cblas::xROT(p.n, x.data(), x.inc(), y.data(), y.inc(), c, s);
stop_reference_test();
// test ampblas
start_ampblas_test();
ampblas_xrot(p.n, x_amp.data(), x.inc(), y_amp.data(), y_amp.inc(), c, s);
stop_ampblas_test();
// synchronize outputs
y_amp.synchronize();
x_amp.synchronize();
// calculate errors
check_error(x, x_amp);
check_error(y, y_amp);
}
/* Inserts and removes strings in a map, in random order. */
static void
test_random_sequence (void)
{
const int basis = 3;
const int max_elems = 64;
const int max_trials = 8;
int cnt;
for (cnt = 0; cnt <= max_elems; cnt += 2)
{
int *insertions, *deletions;
int trial;
int i;
insertions = xnmalloc (cnt, sizeof *insertions);
deletions = xnmalloc (cnt, sizeof *deletions);
for (i = 0; i < cnt; i++)
insertions[i] = i | random_value (i, basis);
for (i = 0; i < cnt; i++)
deletions[i] = i | random_value (i, basis);
for (trial = 0; trial < max_trials; trial++)
{
random_shuffle (insertions, cnt, sizeof *insertions);
random_shuffle (deletions, cnt, sizeof *deletions);
test_insert_delete (insertions, deletions, cnt);
}
free (insertions);
free (deletions);
}
}
PROCESS_THREAD(interferer_example, ev, data)
{
PROCESS_EXITHANDLER()
PROCESS_BEGIN();
// Initial configurations on CC2420: channel and tx power
watchdog_stop();
cc2420_set_txpower(CC2420_TXPOWER_MAX);
cc2420_set_channel(INTERFERED_CHANNEL);
printf("HandyMote: interfering continuously with random power\n");
// Interfering continuously with random power
CC2420_SPI_ENABLE();
set_jammer(CARRIER_TYPE);
int randelay, randpower;
while(1){
randpower = random_value(MIN_POWER,MAX_POWER);
randelay = random_value(MIN_TIME,MAX_TIME);
power_jammer(randpower);
clock_delay(randelay);
}
CC2420_SPI_DISABLE();
PROCESS_WAIT_EVENT();
PROCESS_END();
}
std::vector<int> generate_random_keys(uint size, uint max_value) {
std::random_device r;
std::mt19937 generator(r());
std::uniform_int_distribution<int> random_value(-max_value, max_value);
auto keys = std::vector<int>();
while(size--) {
keys.push_back(random_value(generator));
}
return std::move(keys);
}
/* Inserts strings into a map in ascending order, then delete in ascending
order. */
static void
test_insert_ordered (void)
{
const int max_elems = 64;
int *values;
struct string_map map;
int i;
string_map_init (&map);
values = xnmalloc (max_elems, sizeof *values);
for (i = 0; i < max_elems; i++)
{
values[i] = i | random_value (i, 4);
string_map_insert_nocopy (&map, xstrdup (make_key (values[i])),
xstrdup (make_value (values[i])));
check_string_map (&map, values, i + 1);
}
for (i = 0; i < max_elems; i++)
{
string_map_delete (&map, make_key (i));
check_string_map (&map, values + i + 1, max_elems - i - 1);
}
string_map_destroy (&map);
free (values);
}
/* Inserts strings into a map in each possible order, then
removes them in reverse order, up to a specified maximum
size. */
static void
test_insert_any_remove_reverse (void)
{
const int max_elems = 7;
int cnt;
for (cnt = 0; cnt <= max_elems; cnt++)
{
int *insertions, *deletions;
unsigned int permutation_cnt;
int i;
insertions = xnmalloc (cnt, sizeof *insertions);
deletions = xnmalloc (cnt, sizeof *deletions);
for (i = 0; i < cnt; i++)
insertions[i] = i | random_value (i, 2);
for (permutation_cnt = 0;
permutation_cnt == 0 || next_permutation (insertions, cnt);
permutation_cnt++)
{
memcpy (deletions, insertions, sizeof *insertions * cnt);
reverse (deletions, cnt);
test_insert_delete (insertions, deletions, cnt);
}
check (permutation_cnt == factorial (cnt));
free (insertions);
free (deletions);
}
}
/* Inserts strings into a map in each possible order, then removes them in the
same order, up to a specified maximum size. */
static void
test_insert_any_remove_same (void)
{
const int max_elems = 7;
int cnt;
for (cnt = 0; cnt <= max_elems; cnt++)
{
int *values;
unsigned int permutation_cnt;
int i;
values = xnmalloc (cnt, sizeof *values);
for (i = 0; i < cnt; i++)
values[i] = i | random_value (i, 1);
for (permutation_cnt = 0;
permutation_cnt == 0 || next_permutation (values, cnt);
permutation_cnt++)
test_insert_delete (values, values, cnt);
check (permutation_cnt == factorial (cnt));
free (values);
}
}
/**
* Pickup a cache randomly from the known set. If there's no URL used that
* has not been used recently, NULL will be returned. The timestamp for
* the picked URL is updated automatically.
*
* Try to avoid using default bootstrapping URLs if we have more than the
* minimum set of caches in stock...
*
* @return a GWebCache URL or NULL on failure.
*/
static const char *
gwc_pick(void)
{
int count = hset_count(gwc_known_url);
int idx, i;
const char *url = NULL;
time_t now = tm_time();
if (0 == count)
return NULL;
g_assert(count > 0);
g_assert(count <= MAX_GWC_URLS);
g_assert(count == MAX_GWC_URLS || gwc_url_slot < count);
idx = random_value(count - 1);
for (i = 0; i < count; i++) {
time_t stamp = gwc_url[idx].stamp;
if (0 == stamp || delta_time(now, stamp) > 3900) {
url = gwc_url[idx].url;
gwc_url[idx].stamp = now;
break;
}
}
if (GNET_PROPERTY(bootstrap_debug) && url)
g_message("GWC picked webcache \"%s\"", url);
return url;
}
static addr_t
arch_randomize_stack_pointer(addr_t value)
{
STATIC_ASSERT(MAX_RANDOM_VALUE >= B_PAGE_SIZE - 1);
value -= random_value() & (B_PAGE_SIZE - 1);
return value & ~addr_t(0xf);
}
/**
* Pickup a key randomly.
*
* @returns the key string and the index within the key array into `idx'
* and the token key structure used in `tkused'.
*/
static const char *
random_key(time_t now, uint *idx, const struct tokkey **tkused)
{
static bool warned = FALSE;
uint random_idx;
const struct tokkey *tk;
tk = find_tokkey(now);
if (tk == NULL) {
if (!warned) {
g_warning("did not find any token key, version too ancient");
warned = TRUE;
}
STATIC_ASSERT(G_N_ELEMENTS(token_keys) >= 1);
/* Pick the latest (most recent) key set from the array */
tk = &token_keys[G_N_ELEMENTS(token_keys) - 1];
}
random_idx = random_value(tk->count - 1);
*idx = random_idx;
*tkused = tk;
return tk->keys[random_idx];
}
void monte_carlo ( int n, int *seed )
/******************************************************************************/
/*
Purpose:
MONTE_CARLO carries out a Monte Carlo calculation with random values.
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
03 September 2012
Author:
John Burkardt
Parameter:
Input, int N, the number of values to generate.
Input, int *SEED, a seed for the random number generator.
*/
{
int i;
int my_id;
int my_seed;
double *x;
x = ( double * ) malloc ( n * sizeof ( double ) );
# pragma omp master
{
printf ( "\n" );
printf ( " Thread Seed I X(I)\n" );
printf ( "\n" );
}
# pragma omp parallel private ( i, my_id, my_seed ) shared ( n, x )
{
my_id = omp_get_thread_num ( );
my_seed = *seed + my_id;
printf ( " %6d %12d\n", my_id, my_seed );
# pragma omp for
for ( i = 0; i < n; i++ )
{
x[i] = random_value ( &my_seed );
printf ( " %6d %12d %6d %14.6g\n", my_id, my_seed, i, x[i] );
}
}
free ( x );
return;
}
/**
* Randomly swap 1/128 of the array items.
*/
static void
vsort_perturb_sorted_array(void *array, size_t cnt, size_t isize)
{
size_t n;
size_t i;
n = cnt / 128;
for (i = 0; i < n; i++) {
size_t a = random_value(cnt - 1);
size_t b = random_value(cnt - 1);
void *x = ptr_add_offset(array, a * isize);
void *y = ptr_add_offset(array, b * isize);
SWAP(x, y, isize);
}
}
void Random::random_init(unsigned long long seed )
{
unsigned long long i;
ranctx_.a = 0xf1ea5eed, ranctx_.b = ranctx_.c = ranctx_.d = seed;
for (i = 0; i < 20; ++i) {
random_value();
}
}
void ButtonsWidget::choose_random_color() {
int random_number = qrand() % 4;
generate_new_time();
numbers_.push_back(random_number);
qDebug() << "game_iter: [" << game_iter_ << "]" << "numbers_.at(game_iter_) = [" << numbers_.at(game_iter_) << "]";
game_iter_ += 1;
emit random_value(random_number);
}
int main ()
{
FILE *out = fopen ("tests.pairs.10k", "w");
for (int i = 0; i < 10*1024; i++)
{
double x = random_value();
fprintf (out, "%.20g\t%a\n", x, x);
}
}
/**
* Add URL to the global list, randomly inserting at head or tail.
*/
static void
ghc_list_add(struct ghc *ghc)
{
g_return_if_fail(ghc);
if (random_value(100) < 50) {
list_append(ghc_list, ghc);
} else {
list_prepend(ghc_list, ghc);
}
}
/* Inserts strings into a map in each possible order, then removes them in each
possible order, up to a specified maximum size. */
static void
test_insert_any_remove_any (void)
{
const int basis = 0;
const int max_elems = 5;
int cnt;
for (cnt = 0; cnt <= max_elems; cnt++)
{
int *insertions, *deletions;
unsigned int ins_perm_cnt;
int i;
insertions = xnmalloc (cnt, sizeof *insertions);
deletions = xnmalloc (cnt, sizeof *deletions);
for (i = 0; i < cnt; i++)
insertions[i] = i | random_value (i, basis);
for (ins_perm_cnt = 0;
ins_perm_cnt == 0 || next_permutation (insertions, cnt);
ins_perm_cnt++)
{
unsigned int del_perm_cnt;
int i;
for (i = 0; i < cnt; i++)
deletions[i] = i | random_value (i, basis);
for (del_perm_cnt = 0;
del_perm_cnt == 0 || next_permutation (deletions, cnt);
del_perm_cnt++)
test_insert_delete (insertions, deletions, cnt);
check (del_perm_cnt == factorial (cnt));
}
check (ins_perm_cnt == factorial (cnt));
free (insertions);
free (deletions);
}
}
void fill(T& x, std::size_t len) {
value_type* value_ptr = 0;
len += x.size();
for (std::size_t i = 0; i < len; ++i) {
value_type value = generate(value_ptr, type_);
std::size_t count = type_ == generate_collisions ?
random_value(5) + 1 : 1;
for(std::size_t j = 0; j < count; ++j) {
x.push_back(value);
}
}
}
void fill(T& x, std::size_t len) {
key_type* key_ptr = 0;
mapped_type* mapped_ptr = 0;
for (std::size_t i = 0; i < len; ++i) {
key_type key = generate(key_ptr, type_);
std::size_t count = type_ == generate_collisions ?
random_value(5) + 1 : 1;
for(std::size_t j = 0; j < count; ++j) {
x.push_back(std::pair<key_type const, mapped_type>(
key, generate(mapped_ptr, type_)));
}
}
}
static bool
udp_ping_register(const struct guid *muid,
host_addr_t addr, uint16 port,
udp_ping_cb_t cb, void *data, bool multiple)
{
struct udp_ping *ping;
uint length;
g_assert(muid);
g_return_val_if_fail(udp_pings, FALSE);
if (hash_list_contains(udp_pings, muid)) {
/* Probably a duplicate */
return FALSE;
}
/* random early drop */
length = hash_list_length(udp_pings);
if (length >= UDP_PING_MAX) {
return FALSE;
} else if (length > (UDP_PING_MAX / 4) * 3) {
if (random_value(UDP_PING_MAX - 1) < length)
return FALSE;
}
WALLOC(ping);
ping->muid = *muid;
ping->added = tm_time();
{
gnet_host_t host;
gnet_host_set(&host, addr, port);
ping->host = atom_host_get(&host);
}
if (cb != NULL) {
WALLOC0(ping->callback);
ping->callback->cb = cb;
ping->callback->data = data;
ping->callback->multiple = booleanize(multiple);
} else {
ping->callback = NULL;
}
hash_list_append(udp_pings, ping);
return TRUE;
}
static void
add_node_helper(const host_addr_t *addrs, size_t n, gpointer data)
{
struct add_node_context *ctx = data;
g_assert(addrs);
g_assert(ctx);
g_assert(0 != ctx->port);
if (n > 0) {
const host_addr_t addr = addrs[random_value(n - 1)];
if (ctx->g2) {
guc_node_g2_add(addr, ctx->port, ctx->flags);
} else {
guc_node_add(addr, ctx->port, ctx->flags);
}
}
WFREE(ctx);
}
/**
* Called when we get a reply from the ADNS process.
*/
static void
whitelist_dns_cb(const host_addr_t *addrs, size_t n, void *udata)
{
struct whitelist_dns *ctx = udata;
struct whitelist *item = ctx->item;
if (ctx->generation != whitelist_generation) {
if (GNET_PROPERTY(whitelist_debug))
log_whitelist_item(item, "late DNS resolution");
if (!ctx->revalidate) {
whitelist_free(item);
}
} else {
item->host->last_resolved = tm_time();
if (n < 1) {
if (GNET_PROPERTY(whitelist_debug))
log_whitelist_item(item, "could not DNS-resolve");
if (ctx->revalidate) {
item->addr = ipv4_unspecified;
item->bits = 0;
} else {
whitelist_free(item);
}
} else {
item->addr = addrs[random_value(n - 1)]; /* Pick one randomly */
item->bits = addr_default_mask(item->addr);
if (GNET_PROPERTY(whitelist_debug) > 1) {
g_debug("WLIST DNS-resolved %s as %s (out of %zu result%s)",
item->host->name, host_addr_to_string(item->addr),
n, plural(n));
}
if (!ctx->revalidate) {
whitelist_add(item);
}
}
}
WFREE(ctx);
}
static void
make_patterned_map (struct string_map *map, unsigned int pattern, int basis,
int insertions[], int *np)
{
int n;
int i;
string_map_init (map);
n = 0;
for (i = 0; pattern != 0; i++)
if (pattern & (1u << i))
{
pattern &= pattern - 1;
insertions[n] = i | random_value (i, basis);
check (string_map_insert (map, make_key (insertions[n]),
make_value (insertions[n])));
n++;
}
check_string_map (map, insertions, n);
*np = n;
}
static int test_item1(void)
{
int rc = 0;
int val = 0;
log_info("spawned=%d size=%d rank=%d appnum=%d\n", spawned, size, rank, appnum);
log_assert(spawned == 0 || spawned == 1, "");
log_assert(size >= 0, "");
log_assert(rank >= 0, "");
log_assert(rank < size, "");
sprintf(jobid, "%s", __FUNCTION__);
if (PMI2_SUCCESS != (rc = PMI2_Job_GetId(jobid, sizeof(jobid)))) {
log_fatal("PMI2_Job_GetId failed: %d\n", rc);
return rc;
}
log_info("jobid=%s\n", jobid);
log_assert(memcmp(jobid, __FUNCTION__, sizeof(__FUNCTION__)), "");
val = random_value(10, 100);
if (PMI2_SUCCESS != (rc = PMI2_Job_GetRank(&val))) {
log_fatal("PMI2_Job_GetRank failed: %d\n", rc);
return rc;
}
log_assert(rank == val, "");
val = -1;
if (PMI2_SUCCESS != (rc = PMI2_Info_GetSize(&val))) {
log_fatal("PMI2_Info_GetSize failed: %d\n", rc);
return rc;
}
log_assert(0 < val, "");
return rc;
}
// Main function
int main(int argc, char** argv){
int n;// Number of total particles
struct Particle *locals, *refs;// Array of local particles
char *file_name;// File name
// checking the number of parameters
if(argc < 2){
printf("ERROR: Not enough parameters\n");
printf("Usage: %s <number of particles> [<file>]\n", argv[0]);
exit(1);
}
// getting number of particles
n = atoi(argv[1]);
srand(CONSTANT);
// acquiring memory for particle arrays
locals = (struct Particle *) malloc(n * sizeof(struct Particle));
// checking for file information
if(argc == 3){
read_file(locals,n,argv[2]);
refs = (struct Particle *) malloc(n * sizeof(struct Particle));
//read_ref(refs,n,"test_results_1.txt");
} else {
// random initialization of local particle array
for(int j = 0; j < n; j++){
locals[j].x = random_value(POSITION);
locals[j].y = random_value(POSITION);
locals[j].mass = MASS;
locals[j].fx = 0.0;
locals[j].fy = 0.0;
}
}
// starting timer
timerStart();
// particle interaction
compute_self_interaction(locals,n);
// stopping timer
double duration = timerStop();
// printing information on particles
if(argc == 3) {
/*bool Right = CheckResult(locals,refs,n);
if(Right){
printf("Result correct!\n");
}else{
printf("Results are wrong!\n");
}*/
print_particles(locals,n);
}
printf("n=%d\tDuration: %f seconds\n", n,duration);
//printf("Duration: %f seconds\n", duration);
free(refs);
}
int main(int argc, char **argv)
{
int ret = 0;
int rc;
char *str = NULL;
int ti = (argc > 1 ? atoi(argv[1]) : 0);
srand(time(NULL));
str = getenv("VERBOSE");
_verbose = (str ? atoi(str) : _verbose);
str = getenv("LEGACY");
_legacy = (str ? atoi(str) : _legacy);
spawned = random_value(10, 20);
size = random_value(10, 20);
rank = random_value(10, 20);
appnum = random_value(10, 20);
if (PMI2_SUCCESS != (rc = PMI2_Init(&spawned, &size, &rank, &appnum))) {
log_fatal("PMI2_Init failed: %d\n", rc);
return rc;
}
if (!ti || 1 == ti) {
rc = test_item1();
ret += (rc ? 1 : 0);
log_info("TI1 : %s\n", (rc ? "FAIL" : "PASS"));
}
if (!ti || 2 == ti) {
rc = test_item2();
ret += (rc ? 1 : 0);
log_info("TI2 : %s\n", (rc ? "FAIL" : "PASS"));
}
if (!ti || 3 == ti) {
rc = test_item3();
ret += (rc ? 1 : 0);
log_info("TI3 : %s\n", (rc ? "FAIL" : "PASS"));
}
if (!ti || 4 == ti) {
rc = test_item4();
ret += (rc ? 1 : 0);
log_info("TI4 : %s\n", (rc ? "FAIL" : "PASS"));
}
if (!ti || 5 == ti) {
rc = test_item5();
ret += (rc ? 1 : 0);
log_info("TI5 : %s\n", (rc ? "FAIL" : "PASS"));
}
if (!ti || 6 == ti) {
rc = test_item6();
ret += (rc ? 1 : 0);
log_info("TI6 : %s\n", (rc ? "FAIL" : "PASS"));
}
if (!ti || 7 == ti) {
rc = test_item7();
ret += (rc ? 1 : 0);
log_info("TI7 : %s\n", (rc ? "FAIL" : "PASS"));
}
if (!ti || 8 == ti) {
rc = test_item8();
ret += (rc ? 1 : 0);
log_info("TI8 : %s\n", (rc ? "FAIL" : "PASS"));
}
if (!ti || 9 == ti) {
rc = test_item9();
ret += (rc ? 1 : 0);
log_info("TI9 : %s\n", (rc ? "FAIL" : "PASS"));
}
if (PMI2_SUCCESS != (rc = PMI2_Finalize())) {
log_fatal("PMI2_Finalize failed: %d\n", rc);
return rc;
}
return ret;
}
static int test_item9(void)
{
int rc = 0;
int i, j, r;
char symb, symb_start = 'a';
int fence_cnt;
int fence_num = random_value(2, 10);
int keys_per_fence = random_value(10, 100);
int val_size = random_value(10, PMI2_MAX_VALLEN / 10);
int keys_total = 0;
fence_cnt = 0;
while (fence_cnt < fence_num) {
log_info("fence_cnt=%d of fence_num=%d keys_per_fence=%d keys_total=%d val_size=%d\n",
fence_cnt, fence_num, keys_per_fence, keys_total, val_size);
symb = symb_start;
for (i = 0; i < keys_per_fence; i++) {
char key[PMI2_MAX_KEYLEN];
char val[PMI2_MAX_VALLEN] = "";
sprintf(key, "RANK%d-key-%d", rank, i + keys_total);
for (j = 0; j < val_size; j++) {
val[j] = symb;
}
symb++;
if (symb > 'z') {
symb = 'a';
}
if (PMI2_SUCCESS != (rc = PMI2_KVS_Put(key, val))) {
log_fatal("PMI2_KVS_Put [%s=%s] %d\n", key, val, rc);
return rc;
}
log_info("PMI2_KVS_Put [rank=%d %s] %d\n", rank, key, rc);
}
symb_start = symb;
keys_total += keys_per_fence;
if (PMI2_SUCCESS != (rc = PMI2_KVS_Fence())) {
log_fatal("PMI2_KVS_Fence %d\n", rc);
return rc;
}
for (r = 0; r < size; r++) {
int len;
symb = 'a';
for (i = 0; i < keys_total; i++) {
char key[PMI2_MAX_KEYLEN];
char val[PMI2_MAX_VALLEN] = "";
sprintf(key, "RANK%d-key-%d", r, i);
if (PMI2_SUCCESS != (rc = PMI2_KVS_Get(jobid, r, key, val, sizeof(val), &len))) {
log_fatal("PMI2_KVS_Get [%s=?] %d\n", key, rc);
return rc;
}
log_info("PMI2_KVS_Get [rank=%d %s] %d\n", rank, key, rc);
if (len != val_size) {
log_fatal("%d: failure on rank %d, key #%d: len mismatch:"
" %d instead of %d\n", rank, r, i, len, val_size);
}
for (j = 0; j < val_size; j++) {
if (val[j] != symb) {
log_fatal("%d: failure on rank %d, key #%d: value mismatch"
" at symb %d: \'%c\' instead of \'%c\'\n", rank,
r, i, j, val[j], symb);
}
}
symb++;
if (symb > 'z') {
symb = 'a';
}
}
}
fence_cnt++;
}
return rc;
}
int main(int argc, char* argv[])
{
FILE *fp1;
FILE *fp2;
FILE *fp3;
mad_fixed_t X[num_inp], T[num_out], H[num_hid], Y[num_out];
mad_fixed_t W_xh[num_inp][num_hid], W_hy[num_hid][num_out];
mad_fixed_t dW_xh[num_inp][num_hid], dW_hy[num_hid][num_out];
mad_fixed_t Q_h[num_hid], Q_y[num_out];
mad_fixed_t dQ_h[num_hid], dQ_y[num_out];
mad_fixed_t delta_h[num_hid], delta_y[num_out];
mad_fixed_t sum, mse;
int Icycle, Itrain;
int i, j, h;
fp1 = fopen(train_file, "r");
fp2 = fopen(weight_file, "w");
fp3 = fopen(mse_file, "w");
if (fp1 == NULL) {
puts("File not exist !!");
getchar();
exit(1);
}
srand((int)time(0));
for (h = 0; h < num_hid; h++) {
for (i = 0; i < num_inp; i++) {
W_xh[i][h] = random_value();
dW_xh[i][h] = F_ZERO;
}
}
for (j = 0; j <= num_out; j++) {
for (h = 0; h < num_hid; h++) {
W_hy[h][j] = random_value();
dW_hy[h][j] = F_ZERO;
}
}
for (h = 0; h < num_hid; h++) {
Q_h[h] = F_ZERO;
dQ_h[h] = F_ZERO;
delta_h[h] = F_ZERO;
}
for (j = 0; j < num_out; j++) {
Q_y[j] = random_value();
dQ_y[j] = F_ZERO;
delta_y[j] = F_ZERO;
}
/*start learning */
float tmp;
for (Icycle = 0; Icycle < num_cycle; Icycle++) {
mse = F_ZERO;
fseek(fp1, 0, 0);
for (Itrain = 0; Itrain < num_train; Itrain++) {
for (i = 0; i < num_inp; i++) {
tmp = parser(fp1);
X[i] = mad_f_tofixed(tmp);
}
for (j = 0; j < num_out; j++) {
tmp = parser(fp1);
T[j]= mad_f_tofixed(tmp);
}
for (h = 0; h < num_hid; h++) {
sum = F_ZERO;
for (i = 0; i < num_inp; i++) {
sum = mad_f_add(sum, mad_f_mul(X[i], W_xh[i][h]));
}
/* H[h] = (float)1.0 / (1.0 + exp(-(sum - Q_h[h]))); */
tmp = exp(-1.0 * mad_f_todouble(mad_f_sub(sum, Q_h[h])));
mad_fixed_t exp_result = mad_f_tofixed(tmp);
H[h] = mad_f_div(F_POS_ONE, mad_f_add(F_POS_ONE, exp_result));
}
for (j = 0; j < num_out; j++) {
sum = F_ZERO;
for (h = 0; h < num_hid; h++) {
sum = mad_f_add(sum, mad_f_mul(H[h], W_hy[h][j]));
}
/* Y[j] = (float)1.0 / (1.0 + exp(-(sum - Q_y[j]))); */
tmp = exp(-1.0 * mad_f_todouble(mad_f_sub(sum, Q_y[j])));
mad_fixed_t exp_result = mad_f_tofixed(tmp);
Y[j] = mad_f_div(F_POS_ONE, mad_f_add(F_POS_ONE, exp_result));
}
for (j = 0; j < num_out; j++) {
/* delta_y[j] = Y[j] * (1.0 - Y[j]) * (T[j] - Y[j]); */
mad_fixed_t first, second, third;
first = Y[j];
second = mad_f_sub(F_POS_ONE, Y[j]);
third = mad_f_sub(T[j], Y[j]);
delta_y[j] = mad_f_mul(mad_f_mul(first, second), third);
}
for (h = 0; h < num_hid; h++) {
sum = F_ZERO;
for (j = 0; j < num_out; j++) {
/* sum = sum + W_hy[h][j] * delta_y[j]; */
sum = mad_f_add(sum, mad_f_mul(W_hy[h][j], delta_y[j]));
}
/* delta_h[h] = H[h] * (1.0 - H[h]) * sum; */
mad_fixed_t first, second, third;
first = H[h];
second = mad_f_sub(F_POS_ONE, H[h]);
third = sum;
delta_h[h] = mad_f_mul(mad_f_mul(first, second), sum);
}
for (j = 0; j < num_out; j++) {
for (h = 0; h < num_hid; h++) {
/* dW_hy[h][j] = eta * delta_y[j] * H[h] + alpha * dW_hy[h][j]; */
mad_fixed_t first, second;
first = mad_f_mul(mad_f_mul(F_ETA, delta_y[j]), H[h]);
second = mad_f_mul(F_ALPHA, dW_hy[h][j]);
dW_hy[h][j] = mad_f_add(first, second);
}
}
for (j = 0; j < num_out; j++) {
/* dQ_y[j] = -eta * delta_y[j] + alpha * dQ_y[j]; */
mad_fixed_t first, second;
first = mad_f_mul(F_NEG_ETA, delta_y[j]);
second = mad_f_mul(F_ALPHA, dQ_y[j]);
dQ_y[j] = mad_f_add(first, second);
}
for (h = 0; h < num_hid; h++) {
for (i = 0; i < num_inp; i++) {
/* dW_xh[i][h] = eta * delta_h[h] * X[i] + alpha * dW_xh[i][h]; */
mad_fixed_t first, second;
first = mad_f_mul(X[i], mad_f_mul(F_ETA, delta_h[h]));
second = mad_f_mul(F_ALPHA, dW_xh[i][h]);
dW_xh[i][h] = mad_f_add(first, second);
}
}
for (h = 0; h < num_hid; h++) {
/* dQ_h[h] = -eta * delta_h[h] + alpha * dQ_h[h]; */
mad_fixed_t first, second;
first = mad_f_mul(F_NEG_ETA, delta_h[h]);
second = mad_f_mul(F_ALPHA, dQ_h[h]);
dQ_h[h] = mad_f_add(first, second);
}
for (j = 0; j < num_out; j++) {
for (h = 0; h < num_hid; h++) {
/* W_hy[h][j] = W_hy[h][j] + dW_hy[h][j]; */
tmp = mad_f_todouble(W_hy[h][j]);
W_hy[h][j] = mad_f_add(W_hy[h][j], dW_hy[h][j]);
}
}
for (j = 0; j < num_out; j++) {
/* Q_y[j] = Q_y[j] + dQ_y[j]; */
Q_y[j] = mad_f_add(Q_y[j], dQ_y[j]);
}
for (h = 0; h < num_hid; h++) {
for (i = 0; i < num_inp; i++) {
/* W_xh[i][h] = W_xh[i][h] + dW_xh[i][h]; */
W_xh[i][h] = mad_f_add(W_xh[i][h], dW_xh[i][h]);
}
}
for (h = 0; h < num_hid; h++) {
/* Q_h[h] = Q_h[h] + dQ_h[h]; */
Q_h[h] = mad_f_add(Q_h[h], dQ_h[h]);
}
for (j = 0; j < num_out; j++) {
/* mse += (T[j] - Y[j]) * (T[j] - Y[j]); */
mad_fixed_t first, second;
first = mad_f_sub(T[j], Y[j]);
second = mad_f_sub(T[j], Y[j]);
mse = mad_f_add(mse, mad_f_mul(first, second));
}
}
/* mse = mse / num_train; */
mse = mad_f_div(mse, mad_f_tofixed(num_train));
if ((Icycle % 10) == 9) {
printf("\nIcycle=%3d \nmse=%-8.6f\n", Icycle, mad_f_todouble(mse));
fprintf(fp3,"%3d \n%-8.6f\n", Icycle, mad_f_todouble(mse));
}
}
printf("\n");
for (h = 0; h < num_hid; h++) {
for (i = 0; i < num_inp; i++) {
printf("W_xh[%2d][%2d]=%-8.4f\t", i, h, mad_f_todouble(W_xh[i][h]));
fprintf(fp2,"%-8.4f\t", mad_f_todouble(W_xh[i][h]));
}
printf("\n");
fprintf(fp2,"\n");
}
printf("\n");
fprintf(fp2,"\n");
for (j = 0; j < num_out; j++) {
for (h = 0; h < num_hid; h++) {
printf("W_hy[%2d][%2d]=%-8.4f\t", h, j, mad_f_todouble(W_hy[h][j]));
fprintf(fp2,"%-8.4f\t", mad_f_todouble(W_hy[h][j]));
}
printf("\n");
fprintf(fp2,"\n");
}
printf("\n");
fprintf(fp2,"\n");
for (h = 0; h < num_hid; h++) {
printf("Q_h[%2d]=%-8.4f\t", h, mad_f_todouble(Q_h[h]));
fprintf(fp2,"%-8.4f\t", mad_f_todouble(Q_h[h]));
}
printf("\n\n");
fprintf(fp2,"\n\n");
for (j = 0; j < num_out; j++) {
printf("Q_y[%2d]=%-8.4f\t", j, mad_f_todouble(Q_y[j]));
fprintf(fp2,"%-8.4f\t", mad_f_todouble(Q_y[j]));
}
printf("\n\n");
fprintf(fp2,"\n\n");
fclose(fp1);
fclose(fp2);
fclose(fp3);
return 0;
}
int main(int argc, char **argv)
{
int ret = 0;
int rc;
char *str = NULL;
int ti = (argc > 1 ? atoi(argv[1]) : 0);
srand(time(NULL));
str = getenv("VERBOSE");
_verbose = (str ? atoi(str) : _verbose);
spawned = random_value(10, 20);
size = random_value(10, 20);
rank = random_value(10, 20);
appnum = random_value(10, 20);
if (PMI_SUCCESS != (rc = PMI_Init(&spawned))) {
log_fatal("PMI_Init failed: %d\n", rc);
return rc;
}
str = getenv("PMIX_NAMESPACE");
_legacy = (str ? 0 : 1);
/* this test should be always run */
if (1) {
rc = test_item1();
ret += (rc ? 1 : 0);
log_info("TI1 : %s\n", (rc ? "FAIL" : "PASS"));
}
if (!ti || 2 == ti) {
rc = test_item2();
ret += (rc ? 1 : 0);
log_info("TI2 : %s\n", (rc ? "FAIL" : "PASS"));
}
if (!ti || 3 == ti) {
rc = test_item3();
ret += (rc ? 1 : 0);
log_info("TI3 : %s\n", (rc ? "FAIL" : "PASS"));
}
if (!ti || 4 == ti) {
rc = test_item4();
ret += (rc ? 1 : 0);
log_info("TI4 : %s\n", (rc ? "FAIL" : "PASS"));
}
if (!ti || 5 == ti) {
rc = test_item5();
ret += (rc ? 1 : 0);
log_info("TI5 : %s\n", (rc ? "FAIL" : "PASS"));
}
if (!ti || 6 == ti) {
rc = test_item6();
ret += (rc ? 1 : 0);
log_info("TI6 : %s\n", (rc ? "FAIL" : "PASS"));
}
if (!ti || 7 == ti) {
rc = test_item7();
ret += (rc ? 1 : 0);
log_info("TI7 : %s\n", (rc ? "FAIL" : "PASS"));
}
if (PMI_SUCCESS != (rc = PMI_Finalize())) {
log_fatal("PMI_Finalize failed: %d\n", rc);
return rc;
}
return ret;
}