/* * 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); }