/*
* FUnction: NURand
* TPC_C function NURand(A, x, y) =
* (((random1(0,A) | random1(x,y)) + C) % (y - x + 1)) + x
*/
int
NURand(int A, int x, int y)
{
int nurand;
static int C = -1;
if(C == -1)
C = A/2;
nurand = (((random1(0, A) | random1(x, y)) + C) % ( y - x + 1)) + x;
return(nurand);
}
int processHits (GLint hits, GLuint buffer[])
{
if(hits==1)
{
Timer(0); //start timer on first click..
score++;
rectX = random1();
rectY = random1();
}
return score;
}
Vector_3 RandomForce(Vector_3 & v){
static Vector_3 f;
for(int k=0;k<3;k++){
f[k]=Efm*random1()-Tr*v[k];
//Efm*2*(0.5-(double)rrandom()/RAND_MAX)-Tr*v[k];
}
return f;
}
/* Make a string of letter */
static int
MakeNumberString(int min, int max, char *str)
{
static char character[] =
/*** "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; */
"1234567890";
int length;
int i;
length = random1(min, max);
for (i=0; i<length; i++)
{
str[i] = character[random1(0, sizeof(character)-2)];
}
str[length] = '\0';
return length;
}
void Asteroid::applyParams()
{
vertices = new Point[nvertices];
rotatedVertices = new Point[nvertices];
_r = 0.0f;
texScale = 2.0;
texCenterX = random1().frandom(0.3, 0.7);
texCenterY = random1().frandom(0.3, 0.7);
for (int i=0; i< nvertices; i++)
{
float fi = M_PI*2 * i /nvertices;
fi = fi - random1().frandom(-M_PI / (nvertices) /20., M_PI / nvertices /20);
float r1 = _rr * random1().frandom(0.9, 1.1);
if (r1> _r)
_r = r1;
vertices[i] = Point (-r1 * sin(fi) , r1 * cos(fi));
rotatedVertices[i] = vertices[i];
}
initGL();
}
int pseudorand(Element x[SIZE][SIZE],int source,int n,int k,int q,int p)
{
int q1 = GetRand(0,99);
if(q1> q )
return random1(x,source,n,k);
if(q1> p )
return nn(x,source,n,k) ;
else
return maxim(x,source,n,k);
}
int choice(int size, double *s)
{
double ranval;
int index;
ranval = random1(s);
//printf("Ranval %lf\n",ranval);
index = (int)(size * ranval);
//strcpy(res,list[index]);
//printf("Index %d\n",index);
return index;
}
int smallapp::ran_number(int n, int *idum)
{
double t;
int p;
t = random1(idum);
if(t == 1.0) {
t = t - 1.0e-10;
}
p = ( int ) (n * t);
return( p );
}
int
GetPermutation()
{
int r;
while (1) {
r = random1(1, CUST_PER_DIST);
if (cid_array[r]) /* This number already taken */
continue;
cid_array[r] = 1; /* mark taken */
return(r);
}
}
void Asteroid::initParams()
{
x = random1().frandom(-1.0, 1.0);
_rr = random1().frandom(0.06, 0.10);
y = 1.+0.5* _rr;
float _x = view->getShip()->X();
float _y = view->getShip()->Y();
angle = atan2(_x - x, _y - y);
speed = 0.25;
vx = speed* sin (angle);
_rotateSpeed = random1().frandom(-100.1, 100.1);
vy = speed* cos (angle);
nvertices = random1().irandom(MAXVERTICES-20, MAXVERTICES);
//nvertices = 4;
_colorMult.r = random1().frandom (0.7, 1.4);
_colorMult.g = random1().frandom (0.7, 1.4);
_colorMult.b = random1().frandom (0.7, 1.4);
}
int Plasma::init_config(double in_cs=-1.,int distr=ZEROVEL){
int i,j,k;
if(in_cs<0)in_cs=1.;
Vector_3 r;
for(i=0;i<n;i++){// checking distances
int fertig;
do{
for(j=0;j<3;j++){
x[i][j]=in_cs*L*random1(); //2*L*(0.5-(double)random()/RAND_MAX);
//if((i<ni && stable_ions) || distr!=MAXWELL)v[i][j]=0;
//else{
// double delta;
// if(i<ni)delta=2./mass;
// else delta=2.;
//v[i][j]=gaussrand(sqrt(10.*delta),delta);
//}
}
fertig=1;
for(j=0;j<i;j++){
r=x[i]-x[j];
double R=0;
for(k=0;k<3;k++){
if(r[k]>0.5*L)R+=(L-r[k])*(L-r[k]);
else R+=r[k]*r[k];
}
if(R<r0*r0){
printf("Got: %f\n",sqrt(R));
fertig=0;
break;
}
}
}while(!fertig);
}
init_vel(distr);
//if(distr==MAXWELL)vel_scale(1.);
return 0;
}
/// //////////////////////////////////////////////////////////////////////
wxThread::ExitCode ArtSimThread::Entry()
{
const long WAIT_INTERVALL = 250; // milliseconds
m_dlTime = 2000;
m_exitCode = 0; // task result
bool done = false; // task status
unsigned long dlRate = m_pCaller->m_dlRate;
// Sanity check
if ( !m_pCaller ) {
m_exitCode = 2;
done = true;
}
/* ----------------------------------------------------------- */
while(!done)
{
// wxThread obligation
if ( this->TestDestroy() ) {
// must terminate prematurely
this->AbortThread();
}
if (m_pCaller->m_aborted) {
// task was aborted
m_exitCode = 1;
done = true; // thread will die now
}
else {
// this timeslot
wxLongLong now = ::wxGetLocalTimeMillis();
long dt = (now-m_lastTickTime).ToLong();
// cooler handling
int noise = (int)(random1() * 100.0) - 50;
if (m_pCaller->m_coolingBaseFlags) {
if (m_pCaller->m_warmingUp) {
m_pCaller->m_actualTemp += (int)(ART_T_GRADIENT/1000.0*100.0 * dt); // (K/sec) /1000ms *100 ArtTempUnits
if ( m_pCaller->m_actualTemp> (ART_AMBIENT_T*100) ) {
m_pCaller->m_actualTemp = int(ART_AMBIENT_T*100 +noise);
m_pCaller->m_warmingUp=false; // done
}
}
else if (m_pCaller->m_coolingOn) {
if (m_pCaller->m_setpCtrl) {
m_pCaller->m_actualTemp -= (int)(ART_T_GRADIENT/1000.0*100.0 * dt);
if ( m_pCaller->m_actualTemp<=m_pCaller->m_setpoint ) {
m_pCaller->m_actualTemp=m_pCaller->m_setpoint +noise; // setpoint reached
}
}
else {
// no setpoint cooler
; // dont'know yet
}
}
else {
m_pCaller->m_actualTemp = int(ART_AMBIENT_T*100 +noise);
}
}//end cooling support
// image handling
if (m_pCaller->m_camState == CAMERA_IDLE) {
; // nothing to do ..
}// IDLE task
else if (m_pCaller->m_camState == CAMERA_FLUSHING) {
// the real cam would DL the data but not return an image
// set DL status
m_pCaller->m_dlPercent = 100;
m_pCaller->m_abortExposure = false; // not longer
// set true even it's not copied - abort just don't catch the image but retains the state machine
m_pCaller->m_artSample.ready = true; // read done now
// next state
m_pCaller->m_camState = CAMERA_IDLE;
}// FLUSH task
else if (m_pCaller->m_camState == CAMERA_DOWNLOADING) {
if ( (m_endReadTime - now).ToLong()<=0 ) {
// DL done
// copy requested image data into m_artSample
wxUint16* srcPtr;
wxUint16* dstPtr = m_pCaller->m_artSample.imageMem->WordMemPtrRef();
size_t binx = m_pCaller->m_artSample.binX;
size_t ccdw = m_pCaller->m_camProps.nPixelsX;
size_t biny = m_pCaller->m_artSample.binY;
// convert from binned pixels
size_t eWidth = m_pCaller->m_artSample.imageMem->FrameRect().width * binx; // ccd pixels
size_t eHeight = m_pCaller->m_artSample.imageMem->FrameRect().height * biny; // ccd pixels
size_t eX = m_pCaller->m_artSample.imageMem->FrameRect().x; // ccd pixels
size_t eY = m_pCaller->m_artSample.imageMem->FrameRect().y; // ccd pixels
float lastExp = m_pCaller->m_lastExpoDuration;
for (size_t y=eY; y<eY+eHeight; y+=biny) {
for (size_t x=eX; x<eX+eWidth; x+=binx) {
unsigned long pVal = 0;
// binning
for (size_t yy=0; yy<biny; yy++) {
// set the srcPtr to the proper scan line
srcPtr = &m_pCaller->m_imageData[(y+yy)*ccdw + x];
for (size_t xx=0; xx<binx; xx++) {
// integrate row pixels according to the bin size
// scale the values based on exposure length
pVal += (unsigned long)( lastExp*(*srcPtr++) );
}// for xx
}// for yy
// cut binning result to word
*dstPtr++ = (wxUint16)( (pVal<0xffff)?pVal:0xffff );
}// for x
}// for y
// set DL status
m_pCaller->m_dlPercent = 100;
m_pCaller->m_artSample.ready = true; // read done now
// next state
m_pCaller->m_camState = CAMERA_IDLE;
}// DL done
else {
// progress DL
m_pCaller->m_dlPercent = 100 - (100*(m_endReadTime - now).ToLong() / m_dlTime);
}
}// DL task
else if (m_pCaller->m_camState == CAMERA_EXPOSING) {
if ( (m_pCaller->m_endExpoTime - now).ToLong()<=0 ) {
// expo done - get image
//PREPARE READ CCD
m_pCaller->m_dlPercent = 0;
m_dlTime = m_pCaller->m_artSample.dataLength / dlRate; // bytes / kByte/sec = ms download time
m_endReadTime = now + m_dlTime; // 2 sec read for now
// next state
if (m_pCaller->m_abortExposure) {
m_pCaller->m_camState = CAMERA_FLUSHING; // send data to NIL
}
else {
m_pCaller->m_camState = CAMERA_DOWNLOADING;
}
}// expo done
}// EXPO task
else {
// just waiting
;
}
m_lastTickTime = now;
this->Sleep(WAIT_INTERVALL); // now wait a while
} // not aborted
}// thread loop
Exit(&m_exitCode); // exit thread
return &m_exitCode; // thread completed successfully
}
/*
* Loads the Orders table
* Also loads the Order_Line table on the fly
*
* w_id - warehouse id
* d_id - district id
*/
int
Orders(long d_id, long w_id)
{
long o_id;
long o_c_id;
long o_d_id;
long o_w_id;
long o_carrier_id;
long o_ol_cnt;
long ol;
long ol_i_id;
long ol_supply_w_id;
long ol_quantity;
long ol_amount;
char ol_dist_info[25];
float i_price;
float c_discount;
int err;
DBT key, data;
ORDER_PRIMARY_KEY o_key;
ORDER_PRIMARY_DATA o_data;
ORDERLINE_PRIMARY_KEY ol_key;
ORDERLINE_PRIMARY_DATA ol_data;
NEWORDER_PRIMARY_KEY no_key;
printf("Loading Orders for D=%ld, W= %ld\n", d_id, w_id);
o_d_id=d_id;
o_w_id=w_id;
InitPermutation(); /* initialize permutation of customer numbers */
for (o_id=1; o_id<=ORD_PER_DIST; o_id++)
{
memset(&o_key, 0, sizeof(ORDER_PRIMARY_KEY));
memset(&o_data, 0, sizeof(ORDER_PRIMARY_DATA));
o_key.O_D_ID = o_d_id;
o_key.O_W_ID = o_w_id;
o_key.O_ID = o_id;
/* Generate Order Data */
o_c_id = GetPermutation();
o_carrier_id = random1(1L,10L);
o_ol_cnt=random1(5L,15L);
o_data.O_C_ID = o_c_id;
o_data.O_ALL_LOCAL = 1;
o_data.O_OL_CNT = o_ol_cnt;
memcpy(&o_data.O_ENTRY_D, timestamp, 26);
if (o_id > 2100) /* the last 900 orders have not been delivered) */
{
memset(&no_key, 0, sizeof(NEWORDER_PRIMARY_KEY));
o_data.O_CARRIER_ID = 0;
memset(&key, 0, sizeof(DBT));
key.data = &o_key;
key.size = sizeof(ORDER_PRIMARY_KEY);
memset(&data, 0, sizeof(DBT));
data.data = &o_data;
data.size = sizeof(ORDER_PRIMARY_DATA);
if((err=dbp_order->put(dbp_order, 0, &key, &data, 0)))
{
db_error("DB->put", err);
return -1;
}
no_key.NO_O_ID = o_id;
no_key.NO_D_ID = o_d_id;
no_key.NO_W_ID = o_w_id;
memset(&key, 0, sizeof(DBT));
key.data = &no_key;
key.size = sizeof(NEWORDER_PRIMARY_KEY);
memset(&data, 0, sizeof(DBT));
if((err=dbp_neworder->put(dbp_neworder, 0, &key, &data, 0)))
{
db_error("DB->put", err);
return -1;
}
}
else
{
o_data.O_CARRIER_ID = o_carrier_id;
memset(&key, 0, sizeof(DBT));
key.data = &o_key;
key.size = sizeof(ORDER_PRIMARY_KEY);
memset(&data, 0, sizeof(DBT));
data.data = &o_data;
data.size = sizeof(ORDER_PRIMARY_DATA);
if((err=dbp_order->put(dbp_order, 0, &key, &data, 0)))
{
db_error("DB->put", err);
return -1;
}
}
if ( option_debug )
printf( "OID = %ld, CID = %ld, DID = %ld, WID = %ld\n",
o_id, o_c_id, o_d_id, o_w_id);
for (ol=1; ol<=o_ol_cnt; ol++)
{
memset(&ol_key, 0, sizeof(ORDERLINE_PRIMARY_KEY));
memset(&ol_data, 0, sizeof(ORDERLINE_PRIMARY_DATA));
/* Generate Order Line Data */
ol_i_id=random1(1L,MAXITEMS);
ol_supply_w_id=o_w_id;
ol_quantity=5;
ol_amount=0.0;
MakeAlphaString(24,24,ol_dist_info);
ol_key.OL_W_ID = o_w_id;
ol_key.OL_D_ID = o_d_id;
ol_key.OL_O_ID = o_id;
ol_key.OL_NUMBER = ol;
ol_data.OL_I_ID = ol_i_id;
ol_data.OL_SUPPLY_W_ID = o_w_id;
ol_data.OL_QUANTITY = ol_quantity;
memcpy(&ol_data.OL_DIST_INFO, &ol_dist_info, 25);
if (o_id > 2100)
{
ol_data.OL_AMOUNT = ol_amount;
memset(&key, 0, sizeof(DBT));
key.data = &ol_key;
key.size = sizeof(ORDERLINE_PRIMARY_KEY);
memset(&data, 0, sizeof(DBT));
data.data = &ol_data;
data.size = sizeof(ORDERLINE_PRIMARY_DATA);
if((err=dbp_orderline->put(dbp_orderline, 0, &key, &data, 0)))
{
db_error("DB->put", err);
return -1;
}
}
else
{
const int dt_size = 26;
char datetime[dt_size];
time_t t_clock;
if((int)time(&t_clock) == -1)
{
error("time");
exit(1);
}
ctime_r(&t_clock, (char*)datetime);
ol_data.OL_AMOUNT =(float)(random1(10L, 10000L))/100.0;
memcpy(&ol_data.OL_DELIVERY_D, datetime, dt_size);
memset(&key, 0, sizeof(DBT));
key.data = &ol_key;
key.size = sizeof(ORDERLINE_PRIMARY_KEY);
memset(&data, 0, sizeof(DBT));
data.data = &ol_data;
data.size = sizeof(ORDERLINE_PRIMARY_DATA);
if((err=dbp_orderline->put(dbp_orderline, 0, &key, &data, 0)))
{
db_error("DB->put", err);
return -1;
}
}
if ( option_debug )
printf( "OL = %ld, IID = %ld, QUAN = %ld, AMT = %8.2f\n",
ol, ol_i_id, ol_quantity, ol_data.OL_AMOUNT);
}
if ( !(o_id % 100) ) {
printf(".");
if ( !(o_id % 1000) ) printf(" %ld\n",o_id);
}
}
printf("Orders Done.\n");
return 0;
}
/*
* Loads Customer Table
* Also inserts corresponding history record
*
* id - customer id
* d_id - district id
* w_id - warehouse id
*/
int
Customer(long d_id, long w_id )
{
long c_id;
long c_d_id;
long c_w_id;
char c_first[17];
char c_middle[3];
char c_last[17];
char c_street_1[21];
char c_street_2[21];
char c_city[21];
char c_state[3];
char c_zip[10];
char c_phone[17];
char c_since[12];
char c_credit[3];
long c_credit_lim;
float c_discount;
float c_balance;
char c_data[501];
float h_amount;
char h_data[25];
int err;
printf("Loading Customer for DID=%ld, WID=%ld\n",d_id,w_id);
for (c_id=1; c_id<=CUST_PER_DIST; c_id++)
{
DBT key, data;
CUSTOMER_PRIMARY_KEY c_key;
CUSTOMER_PRIMARY_DATA c_primdata;
HISTORY_PRIMARY_KEY h_key;
memset(&c_key, 0, sizeof(CUSTOMER_PRIMARY_KEY));
memset(&c_primdata, 0, sizeof(CUSTOMER_PRIMARY_DATA));
memset(&h_key, 0, sizeof(HISTORY_PRIMARY_KEY));
/* Generate Customer Data */
c_d_id=d_id;
c_w_id=w_id;
MakeAlphaString( 8, 16, c_first );
c_middle[0]='O'; c_middle[1]='E'; c_middle[2] = '\0';
if (c_id <= 1000)
Lastname(c_id-1,c_last);
else
Lastname(NURand(255,0,999),c_last);
MakeAddress( c_street_1, c_street_2, c_city, c_state, c_zip );
MakeNumberString( 16, 16, c_phone );
if (random1(0L,1L))
c_credit[0]='G';
else
c_credit[0]='B';
c_credit[1]='C'; c_credit[2]='\0';
c_credit_lim=50000;
c_discount=((float)random1(0L,50L))/100.0;
c_balance= -10.0;
MakeAlphaString(300,500,c_data);
/* Prepare for putting into the database */
c_key.C_W_ID = c_w_id;
c_key.C_D_ID = c_d_id;
c_key.C_ID = c_id;
memcpy(&c_primdata.C_FIRST, &c_first, 17);
memcpy(&c_primdata.C_MIDDLE, &c_middle, 3);
memcpy(&c_primdata.C_LAST, &c_last, 17);
memcpy(&c_primdata.C_STREET_1, &c_street_1, 21);
memcpy(&c_primdata.C_STREET_2, &c_street_2, 21);
memcpy(&c_primdata.C_CITY, &c_city, 21);
memcpy(&c_primdata.C_STATE, &c_state, 3);
memcpy(&c_primdata.C_ZIP, &c_zip, 10);
memcpy(&c_primdata.C_PHONE, &c_phone, 17);
memcpy(&c_primdata.C_DATA, &c_data, 501);
memcpy(&c_primdata.C_CREDIT, &c_credit, 3);
memcpy(c_primdata.C_CREDIT, &c_credit, 3);
c_primdata.C_DISCOUNT = c_discount;
c_primdata.C_BALANCE = c_balance;
memset(&key, 0, sizeof(DBT));
key.data = &c_key;
key.size = sizeof(CUSTOMER_PRIMARY_KEY);
memset(&data, 0, sizeof(DBT));
data.data = &c_primdata;
data.size = sizeof(CUSTOMER_PRIMARY_DATA);
if((err=dbp_customer->put(dbp_customer, 0, &key, &data, 0)))
{
db_error("DB->put", err);
return -1;
}
h_amount = 10.0;
MakeAlphaString(12,24,h_data);
memset(&key, 0, sizeof(DBT));
key.data = &h_key;
key.size = sizeof(HISTORY_PRIMARY_KEY);
memset(&data, 0, sizeof(DBT));
h_key.H_C_ID = c_id;
h_key.H_C_D_ID = c_d_id;
h_key.H_C_W_ID = c_w_id;
h_key.H_W_ID = c_w_id;
h_key.H_D_ID = c_d_id;
h_key.H_AMOUNT = h_amount;
memcpy(&h_key.H_DATE, ×tamp, 26);
memcpy(&h_key.H_DATA, &h_data, 24);
if((err=dbp_history->put(dbp_history, 0, &key, &data, 0)))
{
db_error("DB->put", err);
return -1;
}
if ( option_debug )
printf( "CID = %ld, LST = %s, P# = %s\n",
c_id, c_last, c_phone );
if ( !(c_id % 100) )
{
printf(".");
if ( !(c_id % 1000) ) printf(" %ld\n",c_id);
}
}
printf("Customer Done.\n");
return 0;
}
/*
* Loads the District table
* w_id - warehouse id
*/
int
District(long w_id)
{
long d_id;
long d_w_id;
char d_name[11];
char d_street_1[21];
char d_street_2[21];
char d_city[21];
char d_state[3];
char d_zip[10];
float d_tax;
float d_ytd;
long d_next_o_id;
DBT key, data;
DISTRICT_PRIMARY_KEY d_key;
DISTRICT_PRIMARY_DATA d_data;
int err;
printf("Loading District\n");
for (d_id=1; d_id<=DIST_PER_WARE; d_id++)
{
memset(&d_key, 0, sizeof(DISTRICT_PRIMARY_KEY));
memset(&d_data, 0, sizeof(DISTRICT_PRIMARY_DATA));
d_w_id=w_id;
d_ytd=30000.0;
d_next_o_id=3001L;
d_key.D_W_ID = d_w_id;
d_key.D_ID = d_id;
d_data.D_YTD = d_ytd;
d_data.D_NEXT_O_ID = d_next_o_id;
/* Generate District Data */
MakeAlphaString(6L,10L,d_name);
MakeAddress( d_street_1, d_street_2, d_city, d_state, d_zip );
d_tax=((float)random1(10L,20L))/100.0;
memcpy(&d_data.D_NAME, &d_name, 11);
memcpy(&d_data.D_STREET_1, &d_street_1, 21);
memcpy(&d_data.D_STREET_2, &d_street_2, 21);
memcpy(&d_data.D_CITY, &d_city, 21);
memcpy(&d_data.D_STATE, &d_state, 3);
memcpy(&d_data.D_ZIP, &d_zip, 10);
d_data.D_TAX = d_tax;
memset(&key, 0, sizeof(DBT));
key.data = &d_key;
key.size = sizeof(DISTRICT_PRIMARY_KEY);
memset(&data, 0, sizeof(DBT));
data.data = &d_data;
data.size = sizeof(DISTRICT_PRIMARY_DATA);
if((err=dbp_district->put(dbp_district, 0, &key, &data, 0)))
{
db_error("DB->put", err);
return -1;
}
if ( option_debug )
printf( "DID = %ld, WID = %ld, Name = %10s, Tax = %5.2f\n",
d_id, d_w_id, d_name, d_tax );
}
return 0;
}
/*
* Loads the Stock table
*
* w_id - warehouse id
*/
int
Stock(long w_id)
{
long s_i_id;
long s_w_id;
long s_quantity;
char s_dist_01[25];
char s_dist_02[25];
char s_dist_03[25];
char s_dist_04[25];
char s_dist_05[25];
char s_dist_06[25];
char s_dist_07[25];
char s_dist_08[25];
char s_dist_09[25];
char s_dist_10[25];
char s_data[51];
int sdatasiz;
long orig[MAXITEMS];
long pos;
int i, err;
DBT key, data;
STOCK_PRIMARY_DATA s_primdata;
STOCK_PRIMARY_KEY s_key;
printf("Loading Stock Wid=%ld\n",w_id);
s_w_id=w_id;
memset(orig, 0, MAXITEMS * sizeof(long));
for (i=0; i<MAXITEMS/10; i++)
{
do
{
pos=random1(0L,MAXITEMS);
} while (orig[pos]);
orig[pos] = 1;
}
for (s_i_id=1; s_i_id<=MAXITEMS; s_i_id++)
{
memset(&s_key, 0, sizeof(STOCK_PRIMARY_KEY));
memset(&s_primdata, 0, sizeof(STOCK_PRIMARY_DATA));
s_key.S_W_ID = s_w_id;
s_key.S_I_ID = s_i_id;
/* Generate Stock Data */
s_quantity=random1(10L,100L);
MakeAlphaString(24,24,s_dist_01);
MakeAlphaString(24,24,s_dist_02);
MakeAlphaString(24,24,s_dist_03);
MakeAlphaString(24,24,s_dist_04);
MakeAlphaString(24,24,s_dist_05);
MakeAlphaString(24,24,s_dist_06);
MakeAlphaString(24,24,s_dist_07);
MakeAlphaString(24,24,s_dist_08);
MakeAlphaString(24,24,s_dist_09);
MakeAlphaString(24,24,s_dist_10);
sdatasiz=MakeAlphaString(26,50,s_data);
memcpy(s_primdata.S_DIST_01, &s_dist_01, 25);
memcpy(s_primdata.S_DIST_02, &s_dist_02, 25);
memcpy(s_primdata.S_DIST_03, &s_dist_03, 25);
memcpy(s_primdata.S_DIST_04, &s_dist_04, 25);
memcpy(s_primdata.S_DIST_05, &s_dist_05, 25);
memcpy(s_primdata.S_DIST_06, &s_dist_06, 25);
memcpy(s_primdata.S_DIST_07, &s_dist_07, 25);
memcpy(s_primdata.S_DIST_08, &s_dist_08, 25);
memcpy(s_primdata.S_DIST_09, &s_dist_09, 25);
memcpy(s_primdata.S_DIST_10, &s_dist_10, 25);
if (orig[s_i_id-1])
{
pos=random1(0L,sdatasiz-8);
s_data[pos]='o';
s_data[pos+1]='r';
s_data[pos+2]='i';
s_data[pos+3]='g';
s_data[pos+4]='i';
s_data[pos+5]='n';
s_data[pos+6]='a';
s_data[pos+7]='l';
}
s_primdata.S_QUANTITY = s_quantity;
memcpy(s_primdata.S_DATA, &s_data, 51);
s_primdata.S_YTD = 0;
s_primdata.S_ORDER_CNT = 0;
s_primdata.S_REMOTE_CNT = 0;
memset(&key, 0, sizeof(DBT));
key.data = &s_key;
key.size = sizeof(STOCK_PRIMARY_KEY);
memset(&data, 0, sizeof(DBT));
data.data = &s_primdata;
data.size = sizeof(STOCK_PRIMARY_DATA);
if((err=dbp_stock->put(dbp_stock, 0, &key, &data, 0)))
{
db_error("DB->put", err);
return -1;
}
if ( option_debug )
printf( "SID = %ld, WID = %ld, Quan = %ld\n",
s_i_id, s_w_id, s_quantity );
if ( !(s_i_id % 100) )
{
printf(".");
if ( !(s_i_id % 5000) ) printf(" %ld\n",s_i_id);
}
}
printf(" Stock Done.\n");
return 0;
}
int mc_simm::step(Plasma &Gas){
int i,j;
Vector_3 *tmp=newc;
static int sttype=1;
int m;
if(one_particle){
m=(int)(Gas.n*(0.5+random1()));
if(m>=Gas.n)m=Gas.n-1;
if(sttype){
newc[0]=Gas.x[m];
for(j=0;j<3;j++){
Gas.x[m][j]+=dc[sttype]*random1();
}
}
else{
newc[0]=Gas.v[m];
for(j=0;j<3;j++){
Gas.x[m][j]+=dc[sttype]*random1();
}
}
}
else{
m=-1;
if(sttype)tmp=Gas.x;
else tmp=Gas.v;
for(i=0;i<Gas.n;i++){
for(j=0;j<3;j++){
newc[i][j]=tmp[i][j]+dc[sttype]*random1();
}
}
if(sttype)Gas.x=newc;
else Gas.v=newc;
}
int mult=1;
double Epot_old=Gas.Epotent;
if(momentum_depend){
Gas.interaction(m);
T=Gas.getT();
Epotent=Gas.Epotent;
mult=2;
}
else{
if(sttype){
Gas.interaction(m,1);
Epotent=Gas.Epotent;
}
else T=Gas.getT();
}
double E2;
if(!diff_temp)E2=1.5*T*Gas.n+Epotent;
else E2=1.5*Gas.Ti*Gas.ni+1.5*Gas.Te*Gas.ne+Epotent;
double Temp=1.;
if(diff_temp && m>=0){
if(m<Gas.ni)Temp=Gas.ini_Ti;
else Temp=Gas.ini_Te;
}
int ac =0;
if(E2<=E1)ac=1;
else{
if(exp((E1-E2)/Temp)>0.5+random1())ac=1;
}
(accept[sttype])+=ac;
nstp++;
if(nstp%nav==0){
aold[0]=accept[0];
aold[1]=accept[1];
accept[1]=accept[0]=0;
nstp=nav;
}
double ratio=mult*get_ratio(sttype);
if(auto_adjust){
double k;
double kmax=1.1,kmax_inv=1./kmax;
if((nstp/2)%5==0){
if(ratio<0.5*kmax_inv)k=kmax_inv;
else if(ratio>0.5*kmax)k=kmax;
else k=ratio/0.5;
dc[sttype]*=k;
if(sttype && dc[sttype]>Gas.L/2)dc[sttype]=Gas.L/2;
}
//printf("%d, %f, %f\n",(one_particle ? m : sttype),ratio,dc[sttype]);
}
if(ac){
if(!one_particle)newc=tmp;
E1=E2;
}
else{ // restoring previous
if(one_particle){
for(i=0;i<Gas.n;i++){
(*Gas.umatr)(i,m)=(*Gas.umatr)(i,i);
//printf("%i -> (%d, %d) [%f]\n",i,i,m,fucktmp[i]);
}
if(sttype){
Gas.x[m]=newc[0];
Gas.rcell(m);
}
else Gas.v[m]=newc[0];
//Gas.Epotent=Epot_old;
//Gas.interaction(m);
// printf("%f\n",Gas.Epotent-Epot_old);
}
else{
if(sttype)Gas.x=tmp;
else Gas.v=tmp;
}
Gas.Epotent=Epot_old;
//Gas.Epotent=E1-1.5*T*Gas.n;
}
if(momentum_depend)sttype=1-sttype;
/*
if(nstp%4==0){
//Gas.is_matr=0;
Gas.interaction(m,1); //to check!
//Gas.is_matr=1;
}*/
return ac;
}
////////////////////////////*BARS*///////////////////////////////////////////////
number()
{ cleardevice();
rectangle(500,130,580,150);outtextxy(503,133,"EXIT");
rectangle(200,100,400,300);
for(a=100;a<300;a=a+50)
{
line(200,a,400,a);
}
for(a=200;a<400;a=a+50)
{
line(a,100,a,300);
}
while(b<=15)
{
r=random1();r++;
h=random2();h++;
switch(h)
{
case 1:x=225;y=125;break;
case 2:x=225;y=175;break;
case 3:x=225;y=225;break;
case 4:x=225;y=275;break;
case 5:x=275;y=125;break;
case 6:x=275;y=175;break;
case 7:x=275;y=225;break;
case 8:x=275;y=275;break;
case 9:x=325;y=125;break;
case 10:x=325;y=175;break;
case 11:x=325;y=225;break;
case 12:x=325;y=275;break;
case 13:x=375;y=125;break;
case 14:x=375;y=175;break;
case 15:x=375;y=225;break;
case 16:x=375;y=275;break;
}
if(r==16)
{
ex=x;ey=y;
}
switch(r)
{
case 1: outtextxy(x,y,c1); break;
case 2: outtextxy(x,y,c2);break;
case 3: outtextxy(x,y,c3);break;
case 4: outtextxy(x,y,c4);break;
case 5: outtextxy(x,y,c5);break;
case 6: outtextxy(x,y,c6);break;
case 7: outtextxy(x,y,c7);break;
case 8: outtextxy(x,y,c8);break;
case 9: outtextxy(x,y,c9);break;
case 10: outtextxy(x,y,c10);break;
case 11: outtextxy(x,y,c11);break;
case 12: outtextxy(x,y,c12);break;
case 13: outtextxy(x,y,c13);break;
case 14: outtextxy(x,y,c14);break;
case 15: outtextxy(x,y,c15);break;
case 16: outtextxy(x,y,c16);break;
}
b++;
}
showmouseptr();
while(flag==0)
{
getmousepos(&button,&x,&y);
if(button==1&&x>500&&x<580&&y>130&&y<150)exit(0);
/////////////////main logic//////////////
if(button==1&&((x>ex-75&&x<ex-25&&y<ey+25&&y>ey-25)||(x>ex-25&&x<ex+25&&y<ey-25&&y>ey-75)||(x>ex+25&&x<ex+75&&y>ey-25&&y<ey+25)||(x>ex-25&&x<ex+25&&y>ey+25&&y<ey+75))&&(x>200&&x<400&&y<300&&y>100))
{ cx=x-(x%50);cy=y-(y%50);
size=imagesize(cx+2,cy+2,cx+48,cy+48);
buf=malloc(size);
hidemouseptr();
getimage(cx+2,cy+2,cx+48,cy+48,buf);
putimage(ex-23,ey-23,buf,0);
free(buf);
setfillstyle(SOLID_FILL,GREEN);
bar(cx+2,cy+2,cx+48,cy+48);
ex=cx+25;ey=cy+25;
showmouseptr();
}
/////////////////
}
return(0);
}
main(int argc, char **argv)
{
int i, j, k, l, m, n;
char **src_seq, **src_name;
int *len_seq, num_seq;
char temp[100];
ALIGN **align, *aln, *aln0;
FILE *fp;
readpar();
random1(&idum);
initenv(argc, argv);
/* Input the length of the reads (required) */
len_seq = (int *) ckalloc(2 * sizeof(int));
src_seq = (char **) ckalloc(2 * sizeof(char *));
src_name = (char **) ckalloc(1 * sizeof(char *));
src_name[0] = (char *) ckalloc(100 * sizeof(char));
fp = ckopen(seqfile, "r");
num_seq = readseq1by1(src_seq, src_name, len_seq, fp);
fclose(fp);
printf("Genome length: %d\n", len_seq[0]);
/* Make reverse complements of input sequences rev(i) --> i + num_seq */
len_seq[1] = len_seq[0];
src_seq[1] = (char *) ckalloc(len_seq[0] * sizeof(char));
for(j = 0; j < len_seq[0]; j ++) {
src_seq[1][j] = rev(src_seq[0][len_seq[0] - j - 1]);
}
/* read in pairwise alignments by Reputer */
align = (ALIGN **) ckalloc(2 * sizeof(ALIGN *));
fp = ckopen(inpfile, "r");
n = readph(align, src_seq, len_seq, fp, min_leg, min_id);
fclose(fp);
printf("# alignments input: %d.\n", n);
/* Write alignments */
fp = ckopen(outfile, "w");
for(m = 0; m < 2; m ++) {
n = size_align(align[m]);
fwrite(&n, sizeof(int), 1, fp);
aln = align[m];
while(aln) {
fwrite(&(aln -> reads[1]), sizeof(int), 1, fp);
fwrite(&(aln -> mis_match), sizeof(int), 1, fp);
fwrite(&(aln -> length), sizeof(int), 1, fp);
fwrite(aln -> pos[0], sizeof(int), aln -> length, fp);
fwrite(aln -> pos[1], sizeof(int), aln -> length, fp);
aln0 = aln -> next;
free((void *) aln -> pos[0]);
free((void *) aln -> pos[1]);
free((void *) aln);
aln = aln0;
}
}
fclose(fp);
printf("Done...\n");
free((void **) align);
for(i = 0; i < 2 * num_seq; i ++) {
free((void *) src_seq[i]);
}
for(i = 0; i < num_seq; i ++) {
free((void *) src_name[i]);
}
free((void **) src_seq);
free((void **) src_name);
free((void *) len_seq);
}
main(int argc, char **argv)
{
int i, j, k, l, m, n;
int dist[20];
int reads;
int num_vertex, num_class, num_edge;
int *len_seq, num_seq, num_remain;
int **num_pa;
char **src_seq, **src_name;
char temp[100];
ALIGN **eq_class, *align;
EDGE **edge, *edge1, *edge2, *bal_edge1, *bal_edge2;
PATH *path;
int num_path;
NODES **vertex, *begin, *node, *node_next, **start_node;
LIST **list;
READINTERVAL *readinterval;
POSITION *position;
FILE *fp, *fp1;
readpar();
random1(&idum);
initenv(argc, argv);
printf("%d %d %d\n", sizeof(POSITION), sizeof(NODES), sizeof(LIST));
/* Input the length of the genome (required) */
len_seq = (int *) ckalloc(2 * MAX_NUM * sizeof(int));
src_name = alloc_name(MAX_NUM, 100);
fp = ckopen(lenfile, "r");
num_seq = readlen(fp, len_seq, src_name);
fclose(fp);
src_seq = (char **) ckalloc(2 * num_seq * sizeof(char *));
l = 0;
printf("Genome length: ");
for(i = 0; i < num_seq; i ++) {
l += len_seq[i];
printf("%d ", len_seq[i]);
}
printf("\n");
printf("Total length: %d\n", l);
/* Make reverse complements of input sequences rev(i) --> i + num_seq */
for(i = 0; i < num_seq; i ++) {
len_seq[i + num_seq] = len_seq[i];
src_seq[i] = (char *) ckalloc(len_seq[i] * sizeof(char));
src_seq[i + num_seq] = (char *) ckalloc(len_seq[i] * sizeof(char));
for(j = 0; j < len_seq[i]; j ++) {
src_seq[num_seq + i][j] = rev(src_seq[i][len_seq[i] - j - 1]);
}
}
/* Input equivalent readintervales between reads --
see the format of the equivalent readinterval files */
printf("Read equivalent readintervales...\n");
eq_class = (ALIGN **) ckalloc(2 * num_seq * sizeof(ALIGN *));
fp = ckopen(inpfile, "r");
num_class = readclass(eq_class, num_seq, fp);
fclose(fp);
printf("# equivalent readintervales input: %d\n", num_class);
/*
for(i = 0; i < 2 * num_seq; i ++) {
align = eq_class[i];
while(align) {
printf("See: \n");
output_align(align, src_name, src_seq, len_seq, num_seq);
getchar();
align = align -> next;
}
}
*/
/* Initialize the nodes: each position in each read is assigned
as a new node. An array of "list" is set up for each read */
list = (LIST **) ckalloc(2 * num_seq * sizeof(LIST *));
for(i = 0; i < 2 * num_seq; i ++) {
list[i] = (LIST *) ckalloc(len_seq[i] * sizeof(LIST));
}
printf("intitialize nodes...\n");
initialize(list, len_seq, num_seq);
printf("done.\n");
n = countnode(list, len_seq, 2 * num_seq);
printf("# of nodes before merge: %d\n", n);
/* Glue together two nodes if their corresponding positions are defined
as equivalent in a pairwise alignment */
printf("Merge...\n");
merge(num_seq, len_seq, eq_class, num_class, list);
printf("done.\n");
for(i = 0; i < num_seq; i ++) {
while(eq_class[i]) {
eq_class[i] = free_align(eq_class[i]);
}
}
free((void **) eq_class);
/* Compute the width of each node */
for(i = 0; i < 2 * num_seq; i ++) {
for(j = 0; j < len_seq[i]; j ++) {
if(!list[i][j].node -> visit) {
list[i][j].node -> num_path = countthickness(list[i][j].node);
list[i][j].node -> visit = 1;
}
}
}
cleannode(list, len_seq, 2 * num_seq);
n = countnode(list, len_seq, 2 * num_seq);
printf("# of nodes after merge: %d\n", n);
/* Add edges to the graph */
edge = (EDGE **) ckalloc(n * sizeof(EDGE *));
num_edge = graph(num_seq, len_seq, list, edge);
printf("# edges: %d\n", num_edge);
start_node = (NODES **) ckalloc(num_seq * sizeof(NODES *));
for(i = 0; i < num_seq; i ++) {
if(len_seq[i] > 0) {
start_node[i] = list[i][0].node;
} else {
start_node[i] = (NODES *) NULL;
}
}
for(i = 0; i < 2 * num_seq; i ++) {
free((void *) list[i]);
}
free((void **) list);
vertex = (NODES **) ckalloc(2 * num_edge * sizeof(NODES *));
num_vertex = count_vertex(edge, num_edge, vertex);
free((void **) edge);
num_pa = (int **) ckalloc(MAX_BRA * sizeof(int *));
for(i = 0; i < MAX_BRA; i ++) {
num_pa[i] = (int *) ckalloc(MAX_BRA * sizeof(int));
}
num_edge = count_edge_simp(vertex, num_vertex, num_pa);
printf("%d vertices %d edges (%d source %d sinks) remained.\n", num_vertex, num_edge,
num_pa[0][1], num_pa[1][0]);
/* Assign the complementary edges of each edge */
for(i = 0; i < num_vertex; i ++) {
for(j = 0; j < vertex[i] -> num_nextedge; j ++) {
edge1 = vertex[i] -> nextedge[j];
edge1 -> bal_edge = find_bal_edge(edge1, len_seq, num_seq, i);
}
}
/* Remove bulges in the graph */
printf("Shave...\n");
num_vertex = shave_graph(vertex, num_vertex);
printf("done.\n");
/* Remove cycles shorter than some threshold in the graph */
/*
printf("Shaving graph...\n");
num_vertex = rem_cycle(vertex, num_vertex);
printf("done.\n%d vertices remained.\n", num_vertex);
*/
/* remove short edges */
/*
printf("Remove shortedges...\n");
num_vertex = rem_short_edge(vertex, num_vertex, len_seq);
printf("done.\n%d vertices remained.\n", num_vertex);
fflush(stdout);
*/
num_edge = count_edge_simp(vertex, num_vertex, num_pa);
printf("%d vertices %d edges (%d source %d sinks) remained.\n", num_vertex, num_edge,
num_pa[0][1], num_pa[1][0]);
fflush(stdout);
/* Allocate the spaces for paths */
printf("Allocating paths...\n");
for(i = 0; i < num_vertex; i ++) {
vertex[i] -> num_path = 0;
}
/* Build sequence paths */
printf("Define paths...\n");
m = 0;
for(i = 0; i < num_vertex; i ++) {
for(j = 0; j < vertex[i] -> num_nextedge; j ++) {
m += vertex[i] -> nextedge[j] -> multip;
}
}
path = (PATH *) ckalloc(2 * num_seq * sizeof(PATH));
for(i = 0; i < 2 * num_seq; i ++) {
path[i].edge = (EDGE **) ckalloc(m * sizeof(EDGE *));
}
num_path = readpath(start_node, path, num_seq);
free((void **) start_node);
num_edge = count_edge_simp(vertex, num_vertex, num_pa);
m = l = 0;
for(i = 0; i < num_vertex; i ++) {
for(j = 0; j < vertex[i] -> num_nextedge; j ++) {
l += vertex[i] -> nextedge[j] -> length;
if(vertex[i] -> nextedge[j] -> length > m) {
m = vertex[i] -> nextedge[j] -> length;
}
}
}
printf("%d vertics %d edges (%d source %d sinks) remained: total length %d (maximal %d).\n", num_vertex, num_edge,
num_pa[0][1], num_pa[1][0], l, m);
fflush(stdout);
/* Make consensus of edges */
initial_edge(vertex, num_vertex, src_seq, num_seq);
printf("edge initialed\n");
/* Output sequence path */
n = 0;
for(i = 0; i < num_vertex; i ++) {
vertex[i] -> visit = i;
for(j = 0; j < vertex[i] -> num_nextedge; j ++) {
vertex[i] -> nextedge[j] -> start_cover = n;
n ++;
}
}
for(m = 0; m < num_seq; m ++) {
printf("len_path %d\n", path[m].len_path);
printf("Sequence%d: ", m + 1);
for(i = 0; i < path[m].len_path; i ++) {
printf("%d -- %d(%d,%d) --> ", path[m].edge[i] -> begin -> visit,
path[m].edge[i] -> start_cover, path[m].edge[i] -> multip,
path[m].edge[i] -> length);
if(i % 5 == 4) {
printf("\n");
}
}
if(path[m].len_path > 0) {
printf("%d\n", path[m].edge[i - 1] -> end -> visit);
} else {
printf("\n");
}
fflush(stdout);
}
/* Output graph & contigs */
sprintf(temp, "%s.edge", seqfile);
fp = ckopen(temp, "w");
sprintf(temp, "%s.graph", seqfile);
fp1 = ckopen(temp, "w");
write_graph(vertex, num_vertex, fp, fp1);
fclose(fp);
fclose(fp1);
/* Output read intervals in each edge */
sprintf(temp, "%s.intv", seqfile);
fp = ckopen(temp, "w");
write_interval(vertex, num_vertex, fp);
fclose(fp);
/* Output graphviz format graph */
sprintf(temp, "%s", outfile);
fp = ckopen(temp, "w");
output_graph(vertex, num_vertex, fp);
fclose(fp);
for(i = 0; i < MAX_BRA; i ++) {
free((void *) num_pa[i]);
}
free((void **) num_pa);
for(i = 0; i < 2 * num_seq; i ++) {
if(path[i].len_path > 0) {
free((void **) path[i].edge);
}
}
free((void *) path);
free_graph(vertex, num_vertex);
for(i = 0; i < 2 * num_seq; i ++) {
free((void *) src_seq[i]);
}
free((void **) src_seq);
free_name(src_name, MAX_NUM);
free((void *) len_seq);
}
/*
* Loads the Item table
*/
void
LoadItems(void)
{
long i_id;
char i_name[25];
char i_data[51];
float i_price;
int idatasiz, orig[MAXITEMS], i, err, pos;
DB *db, *db_sec;
/* Create/open a new Berkeley DB for the Item index */
if(create_db(db_env, &db, DB_COMMON_PAGE_SIZE, 0) || open_db(db, ITEM_INDEX_NAME, 0))
{
exit(1);
}
printf("Loading Item \n");
for (i=0; i<MAXITEMS; i++)
{
orig[i]=0;
}
for (i=0; i<MAXITEMS/10; i++)
{
do
{
pos = random1(0L,MAXITEMS);
} while (orig[pos]);
orig[pos] = 1;
}
for (i_id=1; i_id<=MAXITEMS; i_id++)
{
DBT key, data;
ITEM_PRIMARY_KEY i_key;
ITEM_PRIMARY_DATA i_primdata;
memset(&i_key, 0, sizeof(ITEM_PRIMARY_KEY));
memset(&i_primdata, 0, sizeof(ITEM_PRIMARY_DATA));
/* Generate Item Data */
MakeAlphaString( 14, 24, i_name);
i_price=((float) random1(100L,10000L))/100.0;
idatasiz=MakeAlphaString(26,50,i_data);
if (orig[i_id-1])
{
pos = random1(0,idatasiz-8);
i_data[pos]= 'o';
i_data[pos+1] = 'r';
i_data[pos+2] = 'i';
i_data[pos+3] = 'g';
i_data[pos+4] = 'i';
i_data[pos+5] = 'n';
i_data[pos+6] = 'a';
i_data[pos+7] = 'l';
}
if ( option_debug )
{
printf( "IID = %ld, Name= %16s, Price = %5.2f\n",
i_id, i_name, i_price );
}
/* Initialize the key */
memset(&key, 0, sizeof(key));
i_key.I_ID = i_id;
key.data = &i_key;
key.size = sizeof(ITEM_PRIMARY_KEY);
/* Initialize the data */
memset(&data, 0, sizeof(data));
i_primdata.I_IM_ID = 0;
i_primdata.I_PRICE = i_price;
strncpy(i_primdata.I_NAME, i_name, 25);
strncpy(i_primdata.I_DATA, i_data, 51);
data.data = &i_primdata;
data.size = sizeof(ITEM_PRIMARY_DATA);
if((err=db->put(db, 0, &key, &data, 0)))
{
db_error("DB->put", err);
goto done;
}
if ( !(i_id % 100) )
{
printf(".");
if ( !(i_id % 5000) ) printf(" %ld\n",i_id);
}
}
printf("Item Done. \n");
done:
if((err = db->close(db, 0)))
{
db_error("DB->close", err);
}
return;
}
/*
* Loads the Warehouse table
* Loads Stock, District as Warehouses are created
*/
void
LoadWare(void)
{
long w_id;
char w_name[11];
char w_street_1[21];
char w_street_2[21];
char w_city[21];
char w_state[3];
char w_zip[10];
float w_tax;
float w_ytd;
DB *dbp;
char *name = WAREHOUSE_INDEX_NAME;
char *stock_name = STOCK_INDEX_NAME;
char *district_name = DISTRICT_INDEX_NAME;
int err;
if(create_db(db_env, &dbp, DB_WH_PAGE_SIZE, 0) || open_db(dbp, name, 0))
return;
if(create_db(db_env, &dbp_stock, DB_COMMON_PAGE_SIZE, 0) || open_db(dbp_stock, stock_name, 0))
goto done;
if(create_db(db_env, &dbp_district, DB_DS_PAGE_SIZE, 0))
goto done;
if((err = dbp_district->set_bt_compare(dbp_district, district_comparison_func)))
{
db_error("DB->set_bt_compare", err);
goto done;
}
if(open_db(dbp_district, district_name, 0))
{
goto done;
}
printf("Loading Warehouse \n");
for (w_id=1L; w_id<=count_ware; w_id++)
{
DBT key, data;
WAREHOUSE_PRIMARY_KEY w_key;
WAREHOUSE_PRIMARY_DATA w_data;
memset(&w_key, 0, sizeof(WAREHOUSE_PRIMARY_KEY));
memset(&w_data, 0, sizeof(WAREHOUSE_PRIMARY_DATA));
/* Generate Warehouse Data */
MakeAlphaString( 6, 10, w_name);
MakeAddress( w_street_1, w_street_2, w_city, w_state, w_zip );
w_tax=((float)random1(10L,20L))/100.0;
w_ytd=3000000.00;
w_key.W_ID = w_id;
memcpy(&w_data.W_NAME, &w_name, 11);
memcpy(&w_data.W_STREET_1, &w_street_1, 21);
memcpy(&w_data.W_STREET_2, &w_street_2, 21);
memcpy(&w_data.W_CITY, &w_city, 21);
memcpy(&w_data.W_STATE, &w_state, 3);
memcpy(&w_data.W_ZIP, &w_zip, 10);
w_data.W_TAX = w_tax;
w_data.W_YTD = w_ytd;
/* Initialize the key */
memset(&key, 0, sizeof(key));
key.data = &w_key;
key.size = sizeof(WAREHOUSE_PRIMARY_KEY);
/* Initialize the data */
memset(&data, 0, sizeof(data));
data.data = &w_data;
data.size = sizeof(WAREHOUSE_PRIMARY_DATA);
if ( option_debug )
printf( "WID = %ld, Name= %16s, Tax = %5.2f\n",
w_id, w_name, w_tax );
if((err=dbp->put(dbp, 0, &key, &data, 0)))
{
db_error("DB->put", err);
goto done;
}
/** Make Rows associated with Warehouse **/
if(Stock(w_id) || District(w_id))
{
goto done;
}
}
done:
if(dbp)
dbp->close(dbp, 0);
if(dbp_stock)
dbp_stock->close(dbp_stock, 0);
if(dbp_district)
dbp_district->close(dbp_district, 0);
}
double simulate_pair(int length1, int length2, int copynum1, int copynum2, int lengththresh,
double *distchr, int *num_chrseg, int num_chr, int num_seg, int seglength)
{
int i, j, k, l, m, n;
int k1, k2, *d1, *d2;
double s1, s2, s0, r;
int nclosepair;
if(lengththresh > 2 * seglength) {
return(1.0);
}
d1 = (int *) ckalloc(copynum1 * sizeof(int));
d2 = (int *) ckalloc(copynum2 * sizeof(int));
for(j = 0; j < copynum1; j ++) {
s1 = random1(&idum);
s0 = 0;
for(i = 0; i < num_seg; i ++) {
if(s1 > s0) {
d1[j] = i;
break;
}
s0 += distchr[i];
}
}
for(j = 0; j < copynum2; j ++) {
s2 = random1(&idum);
s0 = 0;
for(i = 0; i < num_seg; i ++) {
if(s2 > s0) {
d2[j] = i;
break;
}
s0 += distchr[i];
}
}
r = 0;
for(i = 0; i < copynum1; i ++) {
n = k1 = 0;
for(k = 0; k < num_chr; k ++) {
if(d1[i] == n) {
k1 = 1;
}
n = num_chrseg[k];
}
for(j = 0; j < copynum2; j ++) {
n = k2 = 0;
for(k = 0; k < num_chr; k ++) {
if(d2[j] == n) {
k2 = 1;
}
n = num_chrseg[k];
}
if(d1[i] == d2[j]) {
r += ((double) lengththresh) / (seglength - length1 - length2);
} else if(d1[i] - d2[j] == 1 && k1 == 0 || d2[j] - d1[i] == 1 && k2 == 0) {
r += ((double) lengththresh) / (seglength - length1) * ((double) lengththresh) / (seglength - length2);
}
}
}
free((void *) d1);
free((void *) d2);
return(r);
}
void setStartingLocation(WumpusAgent* agent, struct Environment* environ)
{
int x = random1(environ->Map->xdim);
int y = random1(environ->Map->ydim);
agent->start = getLocationSpecified(environ->Map, 1, 1, x, y);
}
