void* producer(void *ptr) {
int i;
int wait;
while(1) {
wait = (genrand_int32() % 5) + 3;
sleep(wait);
pthread_mutex_lock(&control);
while(bufferLength == (MAX)){
printf("Waiting for consumer... \n");
pthread_cond_wait(&conditionalProd, &control);
}
buffer[bufferLength].wait = (genrand_int32() % 8) + 2;
buffer[bufferLength].value = genrand_int32() % 100;
bufferLength++;
printf("Producer: Produced item with value %d. Buffer at %d \n", buffer[bufferLength-1].value, bufferLength);
pthread_cond_signal(&conditionalCons);
pthread_mutex_unlock(&control);
}
pthread_exit(0);
}
int* makeArray( int size ) {
unsigned long init[4] = { 0x123, 0x234, 0x345, 0x456 };
unsigned long length = 10;
init_by_array( init, length );
int*array = ( int* )malloc( sizeof(int) * size );
if( !array )
return NULL;
int*p = array;
for( int i = 0; i < size; i++ )
*p++ = abs( (int) genrand_int32() >> 16 );
return array;
}
void _encrypt(char * pBuffer, size_t size, size_t seed )
{
// 加密
s_mersenne_twister_status mt;
size_t i;
unsigned long rseed = (seed << 7) ^ 0xA9C36DE1;
init_genrand(&mt, rseed);
for (i = 0; i < size;i++)
{
pBuffer[i] = (char)(pBuffer[i] ^ genrand_int32(&mt));
}
}
static void
prepareNoiseRect(SVGASignedPoint *origin) // OUT
{
const uint32 bytesPerLine = 1024;
static const SVGAGMRImageFormat format = {{{ 32, 24 }}};
const SVGAGuestPtr gPtr = { GMRID_NOISE, 0 };
const uint32 rand = genrand_int32();
Screen_DefineGMRFB(gPtr, bytesPerLine, format);
origin->x = rand & 0x7F;
origin->y = (rand >> 8) & 0x7F;
}
//Generate random numbers
int gen_number(int high, int low) {
int num = 0;
num = (int)genrand_int32();
num = abs(num);
num %= (high - low);
if (num < low)
{
num = low;
}
return num;
}
void init_extra_data(void){
static int done = 0;
int i;
if(done)
return;
init_genrand(0);
for( i = 0 ; i < EXTRA_BYTE; i++)
extra_data[i] = (char) genrand_int32() % 256;
done = 1;
}
bool Th105DataArchiveExtractor::header_crypt_impl(std::vector<unsigned char> &data, unsigned long mt_seed, unsigned char a, unsigned char b, unsigned char c) {
if(data.empty()){
return true;
}
unsigned char * p = &data.front();
init_genrand(mt_seed);
while(p <= &data.back()){
*p ^= genrand_int32() ^ a;
a += b;
b += c;
++p;
}
return true;
}
//__________________________________________________________________________________
_PMathObj _Constant::Random (_PMathObj upperB)
{
if (randomCount == 0) {
randomCount++;
}
_Parameter l = theValue, u=((_Constant*)upperB)->theValue,r = l;
if (u>l) {
r=genrand_int32();
r/=RAND_MAX_32;
r =l+(u-l)*r;
}
return new _Constant (r);
}
int main(int argc, char *argv[]) {
// Disable IO buffering
setbuf(stdin, NULL);
setbuf(stdout, NULL);
std::cout.rdbuf()->pubsetbuf(NULL, 0);
std::cin.rdbuf()->pubsetbuf(NULL, 0);
// Initialization
init_mersenne();
init_direction_table();
init_bitboards();
init_uci_options();
Position::init_zobrist();
Position::init_piece_square_tables();
MaterialInfo::init();
MovePicker::init_phase_table();
init_eval(1);
init_bitbases();
init_threads();
// Make random number generation less deterministic, for book moves
int i = abs(get_system_time() % 10000);
for(int j = 0; j < i; j++)
genrand_int32();
// Process command line arguments
if(argc >= 2) {
if(std::string(argv[1]) == "bench") {
if(argc != 4) {
std::cout << "Usage: glaurung bench <hash> <threads>" << std::endl;
exit(0);
}
benchmark(std::string(argv[2]), std::string(argv[3]));
return 0;
}
}
// Print copyright notice
std::cout << engine_name() << ". "
<< "Copyright (C) 2004-2008 Tord Romstad."
<< std::endl;
// Enter UCI mode
uci_main_loop();
return 0;
}
void ThrowClientHead (edict_t *self, int damage)
{
vec3_t vd;
char *gibname;
if (genrand_int32()&1)
{
gibname = "models/objects/gibs/head2/tris.md2";
self->s.skinnum = 1; // second skin is player
}
else
{
gibname = "models/objects/gibs/skull/tris.md2";
self->s.skinnum = 0;
}
self->s.origin[2] += 32;
self->s.frame = 0;
gi.setmodel (self, gibname);
VectorSet (self->mins, -16, -16, 0);
VectorSet (self->maxs, 16, 16, 16);
self->takedamage = DAMAGE_NO;
self->solid = SOLID_NOT;
self->s.effects = EF_GIB;
self->s.sound = 0;
self->flags |= FL_NO_KNOCKBACK;
//this fixes heads floating in air, i hope!
self->clipmask = MASK_SOLID;
self->groundentity = NULL;
self->movetype = MOVETYPE_BOUNCE;
VelocityForDamage (damage, vd);
VectorAdd (self->velocity, vd, self->velocity);
if (self->client) // bodies in the queue don't have a client anymore
{
self->client->anim_priority = ANIM_DEATH;
self->client->anim_end = self->s.frame;
}
else
{
self->think = NULL;
self->nextthink = 0;
}
gi.linkentity (self);
}
void picksite_ero() // pick a site to erode from
{
// first sample a random location
int i = genrand_int32() % nrows;
int j = genrand_int32() % ncols;
/*
Conditions for erosion:
1) surface higher than basement
2) surface higher or equal to shadow (e.g., not in a shadow zone)
Notes:
This function is an if statement, rather than a while loop to allow
time to pass properly. If the conditions are assessed as part of a
while loop, time stands unnaturally still searching for a site for erosion.
*/
if ((surf[i][j] > bsmt[i][j]) && (surf[i][j] >= shad[i][j]))
{
i_ero = i; j_ero = j; // if conditions are met, set the erosion coordinates
ero_flag = true; // set the flag high
}
else
{
ero_flag = false; // else, no erosion this time, flag is low
}
}
bool CItemManager::SaveItem(CItem *item, uint32 slot)
{
QSqlQuery q(accounts_db.db);
bool result = false;
switch(item->status)
{
case ITEM_CHANGED:
{
accounts_db.LockForWrite();
result = q.exec(Query("UPDATE `character_items` SET `slot` = %u, `type` = %u, `level` = %u, `durability` = %f, `option1` = %u, `option2` = %u, `option3` = %u, `newoption` = %u, `setoption` = %u, `petitem_level` = %u, `petitem_exp` = %u, `joh_option` = %u, `optionex` = %u WHERE `dbuid` = %u;", slot, item->type, item->level, item->durability, item->option1, item->option2, item->option3, item->option_new, item->m_SetOption, item->m_PetItem_Level, item->m_PetItem_Exp, item->m_JewelOfHarmonyOption, item->m_ItemOptionEx, item->dbuid).c_str());
accounts_db.Unlock();
item->status = ITEM_UNCHANGED;
break;
}
case ITEM_NEW:
{
init_genrand(GetTicks());
accounts_db.LockForWrite();
uint32 ncount = 0;
uint32 temp_dbuid = 0;
while(ncount < RETRIES)
{
++ncount;
temp_dbuid = genrand_int32();
result = q.exec(Query("SELECT `id` FROM `character_items` WHERE `dbuid` = %u;", temp_dbuid).c_str());
assert(result);
if(!q.next())
{
break;
}
}
assert(ncount != 0x0fffffff);
item->dbuid = temp_dbuid;
result = q.exec(Query("INSERT IGNORE INTO `character_items` (`dbuid`, `slot`, `type`, `level`, `durability`, `option1`, `option2`, `option3`, `newoption`, `setoption`, `petitem_level`, `petitem_exp`, `joh_option`, `optionex`) VALUES (%u, %u, %u, %u, %f, %u, %u, %u, %u, %u, %u, %u, %u, %u);", item->dbuid, slot, item->type, item->level, item->durability, item->option1, item->option2, item->option3, item->option_new, item->m_SetOption, item->m_PetItem_Level, item->m_PetItem_Exp, item->m_JewelOfHarmonyOption, item->m_ItemOptionEx).c_str());
assert(result);
item->status = ITEM_UNCHANGED;
accounts_db.Unlock();
}
default:
break;
}
if(!result)
{
Log.String("Save item %u db: %u failed: %u.", item->guid, item->dbuid, q.lastError().type());
return false;
}
return true;
}
static void
allocNoise(void)
{
const uint32 numPages = 500;
const uint32 numWords = numPages * PAGE_SIZE / sizeof(uint32);
PPN pages = GMR_DefineContiguous(GMRID_NOISE, numPages);
uint32 *ptr = PPN_POINTER(pages);
int i;
init_genrand(0);
for (i = 0; i < numWords; i++) {
ptr[i] = genrand_int32();
}
}
Application::Application() {
init_mersenne();
init_direction_table();
init_bitboards();
init_uci_options();
Position::init_zobrist();
Position::init_piece_square_tables();
init_eval(1);
init_bitbases();
init_search();
init_threads();
// Make random number generation less deterministic, for book moves
for (int i = abs(get_system_time() % 10000); i > 0; i--)
genrand_int32();
}
int main() {
init_genrand(0);
uint32_t ain[100];
hls::stream<uint32_t> din;
hls::stream<float> dout;
for (int i = 0; i < 100; ++i) {
uint32_t rn = genrand_int32();;
ain[i] = rn;
din.write(rn);
}
float aout[100];
for (int i = 0; i < 100/2; ++i) {
float u1 = to_float(ain[2 * i]);
float u2 = to_float(ain[2 * i + 1]);
box_muller(u1, u2);
aout[2 * i] = u1;
aout[2 * i + 1] = u2;
}
gauss_transform(din, dout);
if (dout.size() != 100) {
std::cout << "wrong size" << std::endl;
return -1;
}
for (int i = 0; i < 100; ++i) {
float hw = dout.read();
float sw = aout[i];
std::cout << i << ": \t" << hw << " \t(hw) - (sw) " << sw <<
std::endl;
if (!(std::isfinite(hw) and std::isfinite(sw) and
std::abs(hw - sw) < 1E-4)) {
std::cout << "ERROR: " << i << ": \t" << hw << " \t(hw|sw) "
<< sw << std::endl;
return -1;
}
}
std::cout << "passed." << std::endl;
return 0;
}
GUID_HIGH CObjectManager::CreateGuid()
{
init_genrand(GetTicks());
GUID_HIGH guid = 0;
uint32 count = 0;
while(count < RETRIES)
{
count++;
guid = GUID_HIGH(genrand_int32());
MapType::iterator it = this->container.find(guid);
if(it == this->container.end())
{
break;
}
}
assert(count != RETRIES);
return guid;
}
PerlinField2D(int seed, int _xs, int _grad_max)
{
xs = _xs;
xsize = map_dim.x / xs;
ssize = xsize*xsize;
grad_max = _grad_max;
xscale = 1.0 / ((float) xs);
seed_twister(seed);
ga = new unsigned char[ssize];
for (int i=0; i<ssize; i++)
{
ga[i] = genrand_int32() % grad_max; //gradient number
}
grad = new float[2*grad_max];
generate_gradient_vectors();
}
void calc_new_sequence () {
/* method to set out a new sequence of random samples, without replacement
*/
int r; // the coordinate to shuffle
int rval; // the value to shuffle
for (int i = len - 1; i > -1; i--) {
r = genrand_int32() % (i + 1); // draw a random integer
rval = vcoords[r]; // get the value
vcoords[r] = vcoords[i]; // shuffle
vcoords[i] = rval; // shuffle
}
// apply the shuffled vcoords to the lookup arrays
for (int i = 0; i < len; i++) {
xs[i] = vcoords[i] / ydim;
ys[i] = vcoords[i] % ydim;
}
}
// Initialise the _population matrix with an array given in parameter
// num: the size of the int* array
// init[month][number of rabbits this month]
void Simulation::Start( const char * outputFileName, int time, int num, int * init[2] ) {
clock_t startBegin;
clock_t startEnd;
_file = fopen( outputFileName, "w+");
startBegin = clock( );
if( init != NULL ) {
for( int i = 0; i < num; ++i ) {
for( int j = 0; j < init[ i ][ 1 ]; ++j ) {
// First we determine if rabbits are mature or not
if( init[ i ][ 0 ] >= 5 && init[ i ][ 0 ] < 8 ) {
// 80% chance being mature between 5 and 8 month
if( genrand_int32( ) % 10 > 1 ) (*_pt)->set_mature( true );
} // At the 8th month, all rabbits are matures
else if( init[ i ][ 0 ] >= 8 ) (*_pt)->set_mature( true );
// If none of this cases, the rabbit is not mature
else (*_pt)->set_mature( false );
// Finaly, rabbits are put in the right list and removed from the pool
_population[ init[ i ][ 0 ] ]->push_back( *_pt );
*_pt = NULL;
if( _pt > _pool ) --_pt;
}
}
}
else {
for( int i = 0; i < num; ++i ) {
// All rabbits have 8 months, and are mature so
(*_pt)->set_mature( true );
// Rabbits are stored in the month 8 <=> block 7
( _population[ 7 ] )->push_back( *_pt );
*_pt = NULL;
if( _pt > _pool ) --_pt;
// // std::cout << "A rabbit is created" << std::endl;
}
}
// Simulation is launched when everything is ready
std::cout << "Result " << MonthSimul( time ) << std::endl;
startEnd = clock( );
fprintf( _file, "%ld\t%f\n", (long) ( startEnd - startBegin ), (double) ( startEnd - startBegin ) / CLOCKS_PER_SEC );
}
int Random::nextInt(int max)
{
return genrand_int32();
/*
long unsigned int rand = genrand_int32();
long unsigned int multiplier = 0x6C078965;
long unsigned int retval;
long unsigned int top = (((uint64_t)(rand * multiplier)) & 0xFFFFFFFF00000000) >> 32;
retval = rand - top;
retval = (top + (retval >> 1)) >> 4;
retval += retval << 1;
retval = retval >> (retval << 3);
retval = rand - retval;
if(retval > max)
retval = max;
return retval;*/
}
void init_world() {
lcdMainOnBottom();
#ifndef NATIVE
// TODO: replace with gettimeofday() or similar
init_genrand(genrand_int32() ^ (IPC->time.rtc.seconds +
IPC->time.rtc.minutes*60 + IPC->time.rtc.hours*60*60 +
IPC->time.rtc.weekday*7*24*60*60));
#else
{
struct timeval tv;
gettimeofday(&tv,NULL);
init_genrand(tv.tv_usec+tv.tv_sec*1000000);
}
#endif
new_game();
torch.run(handler);
}
//{{{void generate_interval_sets(struct interval *A,
// must run init_genrand(seed) first
void generate_interval_sets(struct interval *A,
unsigned int size_A,
unsigned int len_A,
struct interval *B,
unsigned int size_B,
unsigned int len_B,
unsigned int P)
{
int i;
for (i = 0; i < size_A; i++) {
A[i].start = genrand_int32();
A[i].end = A[i].start + len_A;
}
qsort(A, size_A, sizeof(struct interval), compare_interval_by_start);
/*
* Draw a number to see if the next interval will intersect or not.
* Draw a number to get the next interval, make new interval intersect or
* not with the drawn interval based on the first draw.
*/
int p_max = 100;
unsigned int p_mask = get_mask(p_max);
unsigned int i_mask = get_mask(size_A);
unsigned int l_mask = get_mask(len_A);
for (i = 0; i < size_B; i++) {
unsigned int next_i = get_rand(size_A, i_mask);
unsigned int next_p = get_rand(p_max, p_mask);
if (P >= next_p) // intersect
// Pick an rand between start and end to start from
B[i].start = A[next_i].start + get_rand(len_A, l_mask);
else // do not intersect
B[i].start = A[next_i].end + get_rand(len_A, l_mask);
B[i].end = B[i].start + len_B;
}
}
static int l_random_rnd(lua_State *L)
{
uint32_t a, b, r;
MT *m = l_checkRandom(L, 1);
r = genrand_int32(m);
switch (lua_gettop(L)) {
case 1:
lua_pushnumber(L, r);
return 1;
case 2:
a = 1;
b = luaL_checkint(L, 2);
break;
case 3:
a = luaL_checkint(L, 2);
b = luaL_checkint(L, 3);
break;
}
if (a > b) {
int t = a;
a = b;
b = t;
}
#if 0
a = ceil(a);
b = floor(b);
#endif
if (a > b)
return 0;
r = a + (r % (b - a + 1));
lua_pushnumber(L, r);
return 1;
}
unsigned int
Simulator::sequential_random_simulation(const BaseVrp& vrp, Solution& solution)
{
Vehicle *current_vehicle = solution.current_vehicle();
int candidates[200], candidate_size;
while (!solution.is_finish())
{
candidate_size = 0;
/* 次に訪問する顧客の候補を求める */
for (unsigned int i=1; i <= vrp.customer_size(); i++)
{
/* 訪問可能であれば候補に追加 */
if (!solution.is_visit(i) &&
current_vehicle->capacity() + vrp.demand(i) <= vrp.capacity())
{
candidates[candidate_size++] = i;
}
}
if (candidate_size == 0)
{
/* 候補がいなければ次の車両へ */
solution.change_vehicle();
current_vehicle = solution.current_vehicle();
}
else
{
/* 候補の中から無作為に１人選ぶ */
unsigned long r = genrand_int32();
int customer = candidates[(unsigned int)r % candidate_size];
current_vehicle->visit(vrp, customer);
}
}
if (solution.is_feasible())
return solution.compute_total_cost(vrp);
else
return 0;
}
int main(void)
{
int i;
unsigned long init[4]={0x123, 0x234, 0x345, 0x456}, length=4;
init_by_array(init, length);
/* This is an example of initializing by an array. */
/* You may use init_genrand(seed) with any 32bit integer */
/* as a seed for a simpler initialization */
printf("1000 outputs of genrand_int32()\n");
for (i=0; i<1000; i++) {
printf("%10lu ", genrand_int32());
if (i%5==4) printf("\n");
}
printf("\n1000 outputs of genrand_real2()\n");
for (i=0; i<1000; i++) {
printf("%10.8f ", genrand_real2());
if (i%5==4) printf("\n");
}
return 0;
}
/***************************************************************************
* Name : SelectNode
* Brief : 定石の変化度によって候補手を決定する
* Return: 定石番号
****************************************************************************/
BookData *select_node(UINT32 change)
{
BookData *ret = NULL;
sort_book_node(g_bookList, g_booklist_cnt);
if (change == NOT_CHANGE)
{
ret = &g_bookList[0];
}
else if (change != CHANGE_RANDOM) // err = 5%〜20%
{
ret = extract_booklist(g_bookList, g_err_rate, g_booklist_cnt);
}
else // full random
{
ret = &g_bookList[genrand_int32() % g_booklist_cnt];
}
return ret;
}
/***************************************************************************
* Name : extract_booklist
* Brief : 誤差によるノード選択
****************************************************************************/
BookData *extract_booklist(BookData *node_list, double rate, int cnt)
{
int i;
int entry_count = 1;
BookData *extracted_list[36];
extracted_list[0] = &node_list[0]; // best node
double abs_threshold = 160000 * rate;
for (i = 1; i < cnt; i++)
{
if (node_list[0].eval - node_list[i].eval <= abs_threshold)
{
extracted_list[i] = &node_list[i];
entry_count++;
}
}
return extracted_list[genrand_int32() % entry_count];
}
byte IsTkIndivBetter(struct tkIndiv *refTkIndiv, struct tkIndiv *compTkIndiv)
{
static byte r = 0;
if (refTkIndiv->fitness > compTkIndiv->fitness)
{
return 1;
}
else if (refTkIndiv->fitness == compTkIndiv->fitness)
{
/*if (refTkIndiv->length > compTkIndiv->length)
{
return 1;
}
else
{*/
r = ((byte)(genrand_int32()) % 2);
return r;
//return 0;
//}
}
return 0;
}
//一方の引数を指定した場合のテストケースを生成＆ファイル出力
void fix_one(uint32_t a, FILE *fp) {
uint32_t b;
int i;
b = ZERO; fprintf(fp, "%08x %08x\n", a, b); fprintf(fp, "%08x %08x\n", b, a);
b = NZERO; fprintf(fp, "%08x %08x\n", a, b); fprintf(fp, "%08x %08x\n", b, a);
b = INF; fprintf(fp, "%08x %08x\n", a, b); fprintf(fp, "%08x %08x\n", b, a);
b = NINF; fprintf(fp, "%08x %08x\n", a, b); fprintf(fp, "%08x %08x\n", b, a);
for (i = 0; i < 10; i++) {
b = make_nan();
fprintf(fp, "%08x %08x\n", a, b);
fprintf(fp, "%08x %08x\n", b, a);
}
for (i = 0; i < 10; i++) {
b = make_denormal();
fprintf(fp, "%08x %08x\n", a, b);
fprintf(fp, "%08x %08x\n", b, a);
}
for (i = 0; i < 500; i++) {
b = genrand_int32();
fprintf(fp, "%08x %08x\n", a, b);
fprintf(fp, "%08x %08x\n", b, a);
}
}
int main(int argc, char* argv[])
{
int p[4][2], i, im, id, status;
unsigned long mseed, dseed;
off_t nm, nd, msiz, dsiz;
size_t nbuf, mbuf, dbuf;
float *buf;
double dp;
pid_t pid[6]={1,1,1,1,1,1};
sf_file mod=NULL;
sf_file dat=NULL;
sf_file pip=NULL;
sf_init(argc,argv);
mod = sf_input("mod");
dat = sf_input("dat");
if (SF_FLOAT != sf_gettype(mod) ||
SF_FLOAT != sf_gettype(dat))
sf_error("Need float type in mod and dat");
nm = sf_filesize(mod);
nd = sf_filesize(dat);
nbuf = BUFSIZ/sizeof(float);
buf = sf_floatalloc(nbuf);
mseed = (unsigned long) time(NULL);
init_genrand(mseed);
mseed = genrand_int32();
dseed = genrand_int32();
for (i=0; i < argc-1; i++) {
argv[i]=argv[i+1];
}
argv[argc-1] = sf_charalloc(6);
snprintf(argv[argc-1],6,"adj=X");
for (i=0; i < 4; i++) { /* make four pipes */
if (pipe(p[i]) < 0) sf_error("pipe error:");
}
for (i=0; i < 6; i++) { /* fork six children */
if ((pid[i] = fork()) < 0) sf_error("fork error:");
if (0 == pid[i]) break;
}
if (0 == pid[0]) {
/* makes random model and writes it to p[0] */
close(p[0][0]);
close(STDOUT_FILENO);
DUP(p[0][1]);
pip = sf_output("out");
sf_fileflush(pip,mod);
init_genrand(mseed);
for (msiz=nm, mbuf=nbuf; msiz > 0; msiz -= mbuf) {
if (msiz < mbuf) mbuf=msiz;
sf_random(mbuf,buf);
sf_floatwrite(buf,mbuf,pip);
}
}
if (0 == pid[1]) {
/* reads from p[0], runs the program, and writes to p[1] */
close(p[0][1]);
close(STDIN_FILENO);
DUP(p[0][0]);
close(p[1][0]);
close(STDOUT_FILENO);
DUP(p[1][1]);
argv[argc-1][4]='0';
execvp(argv[0],argv);
_exit(1);
}
if (0 == pid[2]) {
/* reads from p[1] and multiplies it with random data */
close(p[1][1]);
close(STDIN_FILENO);
DUP(p[1][0]);
pip = sf_input("in");
init_genrand(dseed);
dp = 0.;
for (dsiz=nd, dbuf=nbuf; dsiz > 0; dsiz -= dbuf) {
if (dsiz < dbuf) dbuf=dsiz;
sf_floatread(buf,dbuf,pip);
for (id=0; id < dbuf; id++) {
dp += buf[id]*genrand_real1 ();
}
}
sf_warning(" L[m]*d=%g",dp);
_exit(2);
}
if (0 == pid[3]) {
/* makes random data and writes it to p[2] */
close(p[2][0]);
close(STDOUT_FILENO);
DUP(p[2][1]);
pip = sf_output("out");
sf_fileflush(pip,dat);
init_genrand(dseed);
for (dsiz=nd, dbuf=nbuf; dsiz > 0; dsiz -= dbuf) {
if (dsiz < dbuf) dbuf=dsiz;
sf_random(dbuf,buf);
sf_floatwrite(buf,dbuf,pip);
}
}
if (0 == pid[4]) {
/* reads from p[2], runs the adjoint, and writes to p[3] */
close(p[2][1]);
close(STDIN_FILENO);
DUP(p[2][0]);
close(p[3][0]);
close(STDOUT_FILENO);
DUP(p[3][1]);
argv[argc-1][4]='1';
execvp(argv[0],argv);
_exit(4);
}
if (0 == pid[5]) {
/* reads from p[3] and multiplies it with random model */
close(p[3][1]);
close(STDIN_FILENO);
DUP(p[3][0]);
pip = sf_input("in");
init_genrand(mseed);
dp = 0.;
for (msiz=nm, mbuf=nbuf; msiz > 0; msiz -= mbuf) {
if (msiz < mbuf) mbuf=msiz;
sf_floatread(buf,mbuf,pip);
for (im=0; im < mbuf; im++) {
dp += buf[im]*genrand_real1 ();
}
}
sf_warning("L'[d]*m=%g",dp);
_exit(5);
}
for (i=0; i < 6; i++) {
if (0 == pid[i]) break;
}
if (6==i) {
/* parent waits */
waitpid(pid[2],&status,0);
waitpid(pid[5],&status,0);
exit(0);
}
}
