/* inplace transpose of 3x3 matrix */ double* transposem_inplace_3d( double *M ) { swap_double( M[1], M[3] ); swap_double( M[2], M[6] ); swap_double( M[5], M[7] ); return M; }
/** Switch the delimiting points of the ring and set the switch flag. */ void swap_ring( Ring *r ) { /* check parameters */ if( r == NULL ) error("swap_ring: invalid ring."); swap_double( &(r->x1), &(r->x2) ); swap_double( &(r->y1), &(r->y2) ); swap_double( &(r->ang_start), &(r->ang_end) ); r->full = 1; }
CRIOGPSPacket CrioReceiver::swapGPSPacket(CRIOGPSPacket& packet) { CRIOGPSPacket swapped_packet = packet; swapped_packet.latitude = swap_double(packet.latitude); swapped_packet.longitude = swap_double(packet.longitude); swapped_packet.lat_std_dev = swap_float(packet.lat_std_dev); swapped_packet.long_std_dev = swap_float(packet.long_std_dev); swapped_packet.solution_status = be32toh(packet.solution_status); swapped_packet.position_type = be32toh(packet.position_type); swapped_packet.differential_age = swap_float(packet.differential_age); swapped_packet.solution_age = swap_float(packet.solution_age); return swapped_packet; }
void send_double (char *name, double double_precision) /* includefile */ { send_string(name); if (swapout) swap_double(&double_precision); fwrite(&double_precision,sizeof(double),1,output); /*fprintf(stderr,"%f\n",double_precision);*/ }
void solve_second(double *coef, double *sol) { double det; double opti; sol[0] = -MAX_ROOT; opti = -2.0 * coef[0]; det = coef[1] * coef[1] + 2.0 * opti * coef[2]; if (det == 0.0) { sol[1] = coef[1] / opti; sol[2] = MAX_ROOT; } else if (det >= 0.0) { det = sqrt(det); sol[1] = (coef[1] - det) / opti; sol[2] = (coef[1] + det) / opti; if (sol[1] > sol[2]) swap_double(sol + 1, sol + 2); sol[3] = MAX_ROOT; } else sol[1] = MAX_ROOT; }
/*! \brief Perform the "sift" operation for the heap-sort algorithm. A heap is a collection of items arranged in a binary tree. Each child node is greater than or equal to its parent. If x[k] is the parent, than its children are x[2k+1] and x[2k+2]. This routine promotes ("sifts up") children that are smaller than their parents. Thus, this is a "inverse" heap, where the smallest element of the heap is the root node. Elements in y are associated with those in x and are reordered accordingly. \param[in] root The root index from which to start sifting. \param[in] lastChild The last child (largest node index) in the sift operation. \param[in,out] x The array to be sifted. \param[in,out] y The array to be sifted accordingly. */ static void heap_sift_2( int root, int lastChild, double x[], double y[] ) { int child; for (; (child = (root * 2) + 1) <= lastChild; root = child) { if (child < lastChild) if ( fabs(x[child]) < fabs(x[child+1]) ) child++; if ( fabs(x[child]) <= fabs(x[root]) ) break; swap_double( x[root], x[child] ); swap_double( y[root], y[child] ); } }
/*! \brief Discard the smallest element of x and contract the heaps. On entry, the numElems of the heap are stored in x[0],...,x[numElems-1], and the smallest element is x[0]. The following operations are performed: -# Swap the first and last elements of both heaps -# Shorten the length of the heaps by one. -# Restore the heap property to the contracted heap x. This effectively makes x[0] the next smallest element in the list. \param[in] numElems The number of elements in the current heap. \param[in,out] x The array to be modified. \param[in,out] y The array to be modified accordingly \return The number of elements in each heap after they have been contracted. */ static int heap_del_min_2( int numElems, double x[], double y[] ) { int lastChild = numElems - 1; assert(numElems > 0); /* Swap the smallest element with the lastChild. */ swap_double( x[0], x[lastChild] ); swap_double( y[0], y[lastChild] ); /* Contract the heap size, thereby discarding the smallest element. */ lastChild--; /* Restore the heap property of the contracted heap. */ heap_sift_2( 0, lastChild, x, y ); return numElems - 1; }
/** Code taken from Wikipedia */ void quicksort(double *array, int begin, int end) { if (end > begin) { double pivot = array[begin]; int l = begin + 1; int r = end+1; while(l < r) { if (array[l] < pivot) { l++; } else { r--; swap_double(array+l, array+r); } } l--; swap_double(array+begin, array+l); if(l>begin) quicksort(array, begin, l); if(end>r) quicksort(array, r, end); } }
int main() { int a = 10; int b = 20; double c = 10.0; double d = 20.0; printf("Before swap: %d %d\n", a, b); swap(&a, &b); printf("After swap: %d %d\n", a, b); printf("Before swap: %lf %lf\n", c, d); swap_double(&c, &d); printf("After swap: %lf %lf\n", c, d); return 0; }
/************************************************************************* mcell_sort_numeric_list: Sort a num_expr_list in ascending numeric order. N.B. This uses bubble sort, which is O(n^2). Don't use it if you expect your list to be very long. The list is sorted in-place. In: head: the list to sort Out: list is sorted *************************************************************************/ void mcell_sort_numeric_list(struct num_expr_list *head) { struct num_expr_list *curr, *next; int done = 0; while (!done) { done = 1; curr = head; while (curr != NULL) { next = curr->next; if (next != NULL) { if (curr->value > next->value) { done = 0; swap_double(&curr->value, &next->value); } } curr = next; } } }
/** Check if ellipse is valid: axes must be positive; ensure big axis is first and orientation in [-pi/2, pi/2]. */ int check_ell( double *eparam ) { /* check parameters */ if( eparam == NULL ) error("check_ell: invalid ellipse."); /* reject if degenerate ellipse (negative axes) */ if( (eparam[2] <= 1) || (eparam[3] <= 1) ) return FALSE; /* make sure 'ax' is the greater axis */ if( eparam[2] < eparam[3] ) { swap_double( &(eparam[2]), &(eparam[3]) ); eparam[4] += M_1_2_PI; } /* reject directly if very thin ellipse, to win time */ if( eparam[2] / eparam[3] > 100 ) return FALSE; /* make sure orientation belongs to [-pi/2, pi/2] */ if( eparam[4] > M_1_2_PI ) eparam[4] -= M_PI; if( eparam[4] > M_PI ) eparam[4] -= M_PI; if( eparam[4] < -M_1_2_PI ) eparam[4] += M_PI; return TRUE; }
// adaptiveMeshConstructor() // Inputs: n (width/height of the square mesh), l (maximum level of refinement), // pointers for the level, x, and y arrays (should be NULL for all three) // Output: number of cells in the adaptive mesh // int adaptiveMeshConstructorWij(const int n, const int l, int** level_ptr, double** x_ptr, double** y_ptr, int **i_ptr, int **j_ptr) { int ncells = SQR(n); // ints used for for() loops later int ic, xc, yc, xlc, ylc, nlc; //printf("\nBuilding the mesh...\n"); // Initialize Coarse Mesh int* level = (int*) malloc(sizeof(int)*ncells); double* x = (double*) malloc(sizeof(double)*ncells); double* y = (double*) malloc(sizeof(double)*ncells); int* i = (int*) malloc(sizeof(int)*ncells); int* j = (int*) malloc(sizeof(int)*ncells); for(yc = 0; yc < n; yc++) { for(xc = 0; xc < n; xc++) { level[n*yc+xc] = 0; x[n*yc+xc] = (real)(TWO*xc+ONE) / (real)(TWO*n); y[n*yc+xc] = (real)(TWO*yc+ONE) / (real)(TWO*n); i[n*yc+xc] = xc; j[n*yc+xc] = yc; } } //printf("Coarse mesh initialized.\n"); // Randomly Set Level of Refinement //unsigned int iseed = (unsigned int)time(NULL); //srand (iseed); srand (0); for(int ii = l; ii > 0; ii--) { for(ic = 0; ic < ncells; ic++) { int jj = 1 + (int)(10.0*rand() / (RAND_MAX+1.0)); // XXX Consider distribution across levels: Clustered at 1 level XXX if(jj>5) {level[ic] = ii;} } } //printf("Levels of refinement randomly set.\n"); // Smooth the Refinement int newcount = -1; while(newcount != 0) { newcount = 0; int lev = 0; for(ic = 0; ic < ncells; ic++) { lev = level[ic]; lev++; // Check bottom neighbor if(ic - n >= 0) { if(level[ic-n] > lev) { level[ic] = lev; newcount++; continue; } } // Check top neighbor if(ic + n < ncells) { if(level[ic+n] > lev) { level[ic] = lev; newcount++; continue; } } // Check left neighbor if((ic%n)-1 >= 0) { if(level[ic-1] > lev) { level[ic] = lev; newcount++; continue; } } // Check right neighbor if((ic%n)+1 < n) { if(level[ic+1] > lev) { level[ic] = lev; newcount++; continue; } } } } //printf("Refinement smoothed.\n"); // Allocate Space for the Adaptive Mesh newcount = 0; for(ic = 0; ic < ncells; ic++) {newcount += (powerOfFour(level[ic]) - 1);} int* level_temp = (int*) malloc(sizeof(int)*(ncells+newcount)); double* x_temp = (double*) malloc(sizeof(double)*(ncells+newcount)); double* y_temp = (double*) malloc(sizeof(double)*(ncells+newcount)); int* i_temp = (int*) malloc(sizeof(int)*(ncells+newcount)); int* j_temp = (int*) malloc(sizeof(int)*(ncells+newcount)); // Set the Adaptive Mesh int offset = 0; for(yc = 0; yc < n; yc++) { for(xc = 0; xc < n; xc++) { ic = n*yc + xc; nlc = (int) SQRT( (real) powerOfFour(level[ic]) ); for(ylc = 0; ylc < nlc; ylc++) { for(xlc = 0; xlc < nlc; xlc++) { level_temp[ic + offset + (nlc*ylc + xlc)] = level[ic]; x_temp[ic + offset + (nlc*ylc + xlc)] = x[ic]-(ONE / (real)(TWO*n)) + ((real)(TWO*xlc+ONE) / (real)(n*nlc*TWO)); y_temp[ic + offset + (nlc*ylc + xlc)] = y[ic]-(ONE / (real)(TWO*n)) + ((real)(TWO*ylc+ONE) / (real)(n*nlc*TWO)); i_temp[ic + offset + (nlc*ylc + xlc)] = i[ic]*pow(2,level[ic]) + xlc; j_temp[ic + offset + (nlc*ylc + xlc)] = j[ic]*pow(2,level[ic]) + ylc; } } offset += powerOfFour(level[ic])-1; } } //printf("Adaptive mesh built.\n"); // Swap pointers and free memory used by Coarse Mesh swap_int(&level, &level_temp); swap_double(&x, &x_temp); swap_double(&y, &y_temp); swap_int(&i, &i_temp); swap_int(&j, &j_temp); free(level_temp); free(x_temp); free(y_temp); free(i_temp); free(j_temp); //printf("Old ncells: %d", ncells); // Update ncells ncells += newcount; //printf("\tNew ncells: %d\n", ncells); // Randomize the order of the arrays int* random = (int*) malloc(sizeof(int)*ncells); int* temp1 = (int*) malloc(sizeof(int)*ncells); real* temp2 = (real*) malloc(sizeof(real)*ncells*2); int* temp3 = (int*) malloc(sizeof(int)*ncells*2); // XXX Want better randomization? XXX // XXX Why is the time between printf() statements the longest part? XXX //printf("Shuffling"); //fflush(stdout); for(ic = 0; ic < ncells; ic++) {random[ic] = ic;} //iseed = (unsigned int)time(NULL); //srand (iseed); srand(0); nlc = 0; for(int ii = 0; ii < 7; ii++) { for(ic = 0; ic < ncells; ic++) { int jj = (int)( ((real)ncells*rand()) / (RAND_MAX+ONE) ); nlc = random[jj]; random[jj] = random[ic]; random[ic] = nlc; } //printf("."); //fflush(stdout); } //printf("\n"); for(ic = 0; ic < ncells; ic++) { temp1[ic] = level[random[ic]]; temp2[2*ic] = x[random[ic]]; temp2[2*ic+1] = y[random[ic]]; temp3[2*ic] = i[random[ic]]; temp3[2*ic+1] = j[random[ic]]; } for(ic = 0; ic < ncells; ic++) { level[ic] = temp1[ic]; x[ic] = temp2[2*ic]; y[ic] = temp2[2*ic+1]; i[ic] = temp3[2*ic]; j[ic] = temp3[2*ic+1]; } free(temp1); free(temp2); free(temp3); free(random); //printf("Adaptive mesh randomized.\n"); *level_ptr = level; *x_ptr = x; *y_ptr = y; *i_ptr = i; *j_ptr = j; //printf("Adaptive mesh construction complete.\n"); return ncells; }
static void swapendian_BPP_header(BPP_SEARCH_HEADER * hdr) /* This is required since it is a binary header */ { int ii; hdr->header_version = swap_int(hdr->header_version); hdr->bit_mode = swap_int(hdr->bit_mode); hdr->num_chans = swap_int(hdr->num_chans); hdr->lmst = swap_int(hdr->lmst); hdr->scan_file_number = swap_int(hdr->scan_file_number); hdr->file_size = swap_int(hdr->file_size); hdr->tape_num = swap_int(hdr->tape_num); hdr->tape_file_number = swap_int(hdr->tape_file_number); hdr->enabled_CBs = swap_int(hdr->enabled_CBs); hdr->mb_start_address = swap_int(hdr->mb_start_address); hdr->mb_end_address = swap_int(hdr->mb_end_address); hdr->mb_start_board = swap_int(hdr->mb_start_board); hdr->mb_end_board = swap_int(hdr->mb_end_board); hdr->mb_vme_mid_address = swap_int(hdr->mb_vme_mid_address); hdr->mb_ack_enabled = swap_int(hdr->mb_ack_enabled); hdr->start_from_ste = swap_int(hdr->start_from_ste); hdr->cb_sum_polarizations = swap_int(hdr->cb_sum_polarizations); hdr->cb_direct_mode = swap_int(hdr->cb_direct_mode); hdr->cb_accum_length = swap_int(hdr->cb_accum_length); hdr->tb_outs_reg = swap_int(hdr->tb_outs_reg); hdr->tb_ste = swap_int(hdr->tb_ste); hdr->tb_stc = swap_int(hdr->tb_stc); hdr->H_deci_factor = swap_int(hdr->H_deci_factor); hdr->GenStat0 = swap_int(hdr->GenStat0); hdr->GenStat1 = swap_int(hdr->GenStat1); hdr->Ack_Reg = swap_int(hdr->Ack_Reg); hdr->dfb_sram_length = swap_int(hdr->dfb_sram_length); hdr->ASYMMETRIC = swap_int(hdr->ASYMMETRIC); hdr->mb_long_ds0 = swap_int(hdr->mb_long_ds0); hdr->aib_serial = swap_int(hdr->aib_serial); hdr->aib_rev = swap_int(hdr->aib_rev); hdr->BACKEND_TYPE = swap_int(hdr->BACKEND_TYPE); hdr->UPDATE_DONE = swap_int(hdr->UPDATE_DONE); hdr->HEADER_TYPE = swap_int(hdr->HEADER_TYPE); hdr->tb_id = swap_int(hdr->tb_id); hdr->aib_if_switch = swap_int(hdr->aib_if_switch); hdr->mb_rev = swap_int(hdr->mb_rev); hdr->mb_serial = swap_int(hdr->mb_serial); hdr->tb_rev = swap_int(hdr->tb_rev); hdr->tb_serial = swap_int(hdr->tb_serial); hdr->mb_xtal_freq = swap_int(hdr->mb_xtal_freq); hdr->scan_num = swap_uint(hdr->scan_num); hdr->ll_file_offset = swap_longlong(hdr->ll_file_offset); hdr->ll_file_size = swap_longlong(hdr->ll_file_size); hdr->length_of_integration = swap_double(hdr->length_of_integration); hdr->samp_rate = swap_double(hdr->samp_rate); hdr->ra_2000 = swap_double(hdr->ra_2000); hdr->dec_2000 = swap_double(hdr->dec_2000); hdr->tele_x = swap_double(hdr->tele_x); hdr->tele_y = swap_double(hdr->tele_y); hdr->tele_z = swap_double(hdr->tele_z); hdr->tele_inc = swap_double(hdr->tele_inc); hdr->Fclk = swap_double(hdr->Fclk); hdr->Har_Clk = swap_double(hdr->Har_Clk); hdr->bandwidth = swap_double(hdr->bandwidth); hdr->rf_lo = swap_double(hdr->rf_lo); hdr->max_dfb_freq = swap_double(hdr->max_dfb_freq); hdr->mjd_start = swap_longdouble(hdr->mjd_start); for (ii = 0; ii < FB_CHAN_PER_BRD; ii++) { hdr->dfb_sram_freqs[ii] = swap_float(hdr->dfb_sram_freqs[ii]); } for (ii = 0; ii < MAX_HARRIS_TAPS; ii++) { hdr->i_hcoef[ii] = swap_int(hdr->i_hcoef[ii]); hdr->q_hcoef[ii] = swap_int(hdr->q_hcoef[ii]); } for (ii = 0; ii < MAXNUMCB; ii++) { hdr->cb_id[ii] = swap_int(hdr->cb_id[ii]); hdr->cb_rev[ii] = swap_int(hdr->cb_rev[ii]); hdr->cb_serial[ii] = swap_int(hdr->cb_serial[ii]); hdr->cb_eprom_mode[ii] = swap_int(hdr->cb_eprom_mode[ii]); } for (ii = 0; ii < MAX_NUM_MF_BOARDS; ii++) { hdr->mf_rev[ii] = swap_int(hdr->mf_rev[ii]); hdr->mf_serial[ii] = swap_int(hdr->mf_serial[ii]); hdr->mf_filt_width[ii] = swap_double(hdr->mf_filt_width[ii]); hdr->mf_atten[ii] = swap_double(hdr->mf_atten[ii]); } for (ii = 0; ii < MAX_NUM_LO_BOARDS; ii++) { hdr->lo_rev[ii] = swap_int(hdr->lo_rev[ii]); hdr->lo_serial[ii] = swap_int(hdr->lo_serial[ii]); hdr->aib_los[ii] = swap_double(hdr->aib_los[ii]); } for (ii = 0; ii < MAXNUMDFB; ii++) { hdr->dfb_mixer_reg[ii] = swap_int(hdr->dfb_mixer_reg[ii]); hdr->dfb_conf_reg[ii] = swap_int(hdr->dfb_conf_reg[ii]); hdr->dfb_sram_addr_msb[ii] = swap_int(hdr->dfb_sram_addr_msb[ii]); hdr->dfb_id[ii] = swap_int(hdr->dfb_id[ii]); hdr->dfb_rev[ii] = swap_int(hdr->dfb_rev[ii]); hdr->dfb_serial[ii] = swap_int(hdr->dfb_serial[ii]); hdr->dfb_sun_program[ii] = swap_int(hdr->dfb_sun_program[ii]); hdr->dfb_eprom[ii] = swap_int(hdr->dfb_eprom[ii]); hdr->dfb_sram_addr[ii] = swap_int(hdr->dfb_sram_addr[ii]); hdr->dfb_har_addr[ii] = swap_int(hdr->dfb_har_addr[ii]); hdr->dfb_clip_adc_neg8[ii] = swap_int(hdr->dfb_clip_adc_neg8[ii]); hdr->dfb_shften_[ii] = swap_int(hdr->dfb_shften_[ii]); hdr->dfb_fwd_[ii] = swap_int(hdr->dfb_fwd_[ii]); hdr->dfb_rvrs_[ii] = swap_int(hdr->dfb_rvrs_[ii]); hdr->dfb_asymmetric[ii] = swap_int(hdr->dfb_asymmetric[ii]); hdr->dfb_i_dc[ii] = swap_double(hdr->dfb_i_dc[ii]); hdr->dfb_q_dc[ii] = swap_double(hdr->dfb_q_dc[ii]); hdr->dfb_gain[ii] = swap_double(hdr->dfb_gain[ii]); } }
void G_xdr_put_double(void *dst, const double *src) { swap_double(dst, src); }
void read_prepfoldinfo(prepfoldinfo * in, char *filename) /* Read a prepfoldinfo data structure from a binary file */ { FILE *infile; int itmp, byteswap = 0; char temp[16]; infile = chkfopen(filename, "rb"); in->numdms = read_int(infile, byteswap); in->numperiods = read_int(infile, byteswap); in->numpdots = read_int(infile, byteswap); in->nsub = read_int(infile, byteswap); in->npart = read_int(infile, byteswap); /* The following is not exactly the most robust, but it should work... */ if (in->npart < 1 || in->npart > 10000) { byteswap = 1; in->numdms = swap_int(in->numdms); in->numperiods = swap_int(in->numperiods); in->numpdots = swap_int(in->numpdots); in->nsub = swap_int(in->nsub); in->npart = swap_int(in->npart); } in->proflen = read_int(infile, byteswap); in->numchan = read_int(infile, byteswap); in->pstep = read_int(infile, byteswap); in->pdstep = read_int(infile, byteswap); in->dmstep = read_int(infile, byteswap); in->ndmfact = read_int(infile, byteswap); in->npfact = read_int(infile, byteswap); itmp = read_int(infile, byteswap); in->filenm = calloc(itmp + 1, sizeof(char)); chkfread(in->filenm, sizeof(char), itmp, infile); itmp = read_int(infile, byteswap); in->candnm = calloc(itmp + 1, sizeof(char)); chkfread(in->candnm, sizeof(char), itmp, infile); itmp = read_int(infile, byteswap); in->telescope = calloc(itmp + 1, sizeof(char)); chkfread(in->telescope, sizeof(char), itmp, infile); itmp = read_int(infile, byteswap); in->pgdev = calloc(itmp + 1, sizeof(char)); chkfread(in->pgdev, sizeof(char), itmp, infile); //chkfread(in->rastr, sizeof(char), 16, infile); { int has_posn = 1, ii; chkfread(temp, sizeof(char), 16, infile); /* Check to see if a position string was written */ for (ii = 0; ii < 16; ii++){ if (!isdigit(temp[ii]) && temp[ii] != ':' && temp[ii] != '.' && temp[ii] != '-' && temp[ii] != '\0'){ has_posn = 0; break; } } if (has_posn){ strcpy(in->rastr, temp); chkfread(in->decstr, sizeof(char), 16, infile); in->dt = read_double(infile, byteswap); in->startT = read_double(infile, byteswap); } else { strcpy(in->rastr, "Unknown"); strcpy(in->decstr, "Unknown"); in->dt = *(double *)(temp + 0); if (byteswap) in->dt = swap_double(in->dt); in->startT = *(double *)(temp + sizeof(double)); if (byteswap) in->startT = swap_double(in->startT); } } in->endT = read_double(infile, byteswap); in->tepoch = read_double(infile, byteswap); in->bepoch = read_double(infile, byteswap); in->avgvoverc = read_double(infile, byteswap); in->lofreq = read_double(infile, byteswap); in->chan_wid = read_double(infile, byteswap); in->bestdm = read_double(infile, byteswap); /* The .pow elements were written as doubles (Why??) */ in->topo.pow = read_float(infile, byteswap); read_float(infile, byteswap); in->topo.p1 = read_double(infile, byteswap); in->topo.p2 = read_double(infile, byteswap); in->topo.p3 = read_double(infile, byteswap); /* The .pow elements were written as doubles (Why??) */ in->bary.pow = read_float(infile, byteswap); read_float(infile, byteswap); in->bary.p1 = read_double(infile, byteswap); in->bary.p2 = read_double(infile, byteswap); in->bary.p3 = read_double(infile, byteswap); /* The .pow elements were written as doubles (Why??) */ in->fold.pow = read_float(infile, byteswap); read_float(infile, byteswap); in->fold.p1 = read_double(infile, byteswap); in->fold.p2 = read_double(infile, byteswap); in->fold.p3 = read_double(infile, byteswap); in->orb.p = read_double(infile, byteswap); in->orb.e = read_double(infile, byteswap); in->orb.x = read_double(infile, byteswap); in->orb.w = read_double(infile, byteswap); in->orb.t = read_double(infile, byteswap); in->orb.pd = read_double(infile, byteswap); in->orb.wd = read_double(infile, byteswap); in->dms = gen_dvect(in->numdms); chkfread(in->dms, sizeof(double), in->numdms, infile); in->periods = gen_dvect(in->numperiods); chkfread(in->periods, sizeof(double), in->numperiods, infile); in->pdots = gen_dvect(in->numpdots); chkfread(in->pdots, sizeof(double), in->numpdots, infile); in->rawfolds = gen_dvect(in->nsub * in->npart * in->proflen); chkfread(in->rawfolds, sizeof(double), in->nsub * in->npart * in->proflen, infile); in->stats = (foldstats *) malloc(sizeof(foldstats) * in->nsub * in->npart); chkfread(in->stats, sizeof(foldstats), in->nsub * in->npart, infile); fclose(infile); if (byteswap) { int ii; for (ii = 0; ii < in->numdms; ii++) in->dms[ii] = swap_double(in->dms[ii]); for (ii = 0; ii < in->numperiods; ii++) in->periods[ii] = swap_double(in->periods[ii]); for (ii = 0; ii < in->numpdots; ii++) in->pdots[ii] = swap_double(in->pdots[ii]); for (ii = 0; ii < in->nsub * in->npart * in->proflen; ii++) in->rawfolds[ii] = swap_double(in->rawfolds[ii]); for (ii = 0; ii < in->nsub * in->npart; ii++) { in->stats[ii].numdata = swap_double(in->stats[ii].numdata); in->stats[ii].data_avg = swap_double(in->stats[ii].data_avg); in->stats[ii].data_var = swap_double(in->stats[ii].data_var); in->stats[ii].numprof = swap_double(in->stats[ii].numprof); in->stats[ii].prof_avg = swap_double(in->stats[ii].prof_avg); in->stats[ii].prof_var = swap_double(in->stats[ii].prof_var); in->stats[ii].redchi = swap_double(in->stats[ii].redchi); } } }
void G_xdr_get_double(double *dst, const void *src) { swap_double(dst, src); }
/** Given conic parameters and extreme points, fill in all the ring parameters. If conic is 1, get circle ring, if 0 get ellipse ring. */ int get_ring( Point *reg, int reg_size, double ang, double *param, double *pext1, double *pext2, int conic, double spir, Ring *r, int *grad_dir, double *foci, int msize ) { double tang; /* check parameters */ if( reg == NULL ) error("get_ring: invalid region."); if( param == NULL ) error("get_ring: invalid conic parameters."); if( r == NULL ) error("get_ring: ring must be non null."); if( foci == NULL ) error("get_ring: foci must be non null."); /* fill in centre */ r->cx = param[0]; r->cy = param[1]; /* Init 'full' flag; by default, set to 0. */ r->full = 0; if( conic == CIRCLE ) { if( !check_circ(param) ) return FALSE; *grad_dir = dir_gradient_circ( reg[0].x, reg[0].y, ang, param ); } else { if( !check_ell(param) ) return FALSE; ellipse_foci( param, foci ); *grad_dir = dir_gradient_ell( reg[0].x, reg[0].y, ang, foci ); } /* fill in axes and orientation: this must be done after check, as for the ellipse the axes might have been swapped, and orientation normalized */ r->ax = param[2]; r->bx = param[3]; r->theta = param[4]; /* fill in extremal points */ r->x1 = pext1[0]; r->y1 = pext1[1]; r->x2 = pext2[0]; r->y2 = pext2[1]; /* if gradient converges, interchange the extremal points to keep trigonometric sense */ if( *grad_dir == 0 ) { swap_double( &(r->x1), &(r->x2) ); swap_double( &(r->y1), &(r->y2) ); } /* set delimiting angles */ r->ang_start = atan2( r->y1 - r->cy, r->x1 - r->cx ); if( r->ang_start < 0 ) r->ang_start += M_2__PI; r->ang_end = atan2( r->y2 - r->cy, r->x2 - r->cx ); if( r->ang_end < 0 ) r->ang_end += M_2__PI; /* if the ends of the last rectangles got interwined, swap the ends of the ring */ if( r->ang_start > r->ang_end ) tang = r->ang_end + M_2__PI; else tang = r->ang_end; if( (spir > M_PI) && (tang - r->ang_start < M_1_2_PI/2.0) ) swap_ring( r ); /* set ring widths */ if( conic == CIRCLE ) circ_ring_width( reg, reg_size, r ); else ell_ring_width( reg, reg_size, r ); /* abnormal case: width of the ring is bigger than little axis -> discard ring */ if( r->wmax - r->wmin > r->bx ) return FALSE; if( r->ax > msize ) return FALSE; return TRUE; }
/**************************************************************************** ** jpl_init_ephemeris( ephemeris_filename, nam, val, n_constants) ** ***************************************************************************** ** ** ** this function does the initial prep work for use of binary JPL ** ** ephemerides. ** ** const char *ephemeris_filename = full path/filename of the binary ** ** ephemeris (on the Willmann-Bell CDs, this is UNIX.200, 405, ** ** or 406) ** char nam[][6] = array of constant names (max 6 characters each) ** ** You can pass nam=NULL if you don't care about the names ** ** double *val = array of values of constants ** ** You can pass val=NULL if you don't care about the constants ** ** Return value is a pointer to the jpl_eph_data structure ** ** NULL is returned if the file isn't opened or memory isn't alloced ** ****************************************************************************/ void * DLL_FUNC jpl_init_ephemeris( const char *ephemeris_filename, char nam[][6], double *val) { int i, j; JPLlong de_version; char title[84]; FILE *ifile; struct jpl_eph_data *rval; struct interpolation_info *iinfo; ifile = fopen( ephemeris_filename, "rb"); if( !ifile) return( NULL); /* Rather than do three separate allocations, everything */ /* we need is allocated in _one_ chunk, then parceled out. */ /* This looks a little weird, but it does simplify error */ /* handling and cleanup. */ rval = (struct jpl_eph_data *)calloc( sizeof( struct jpl_eph_data) + sizeof( struct interpolation_info) + MAX_KERNEL_SIZE * 4, 1); if( !rval) { fclose( ifile); return( NULL); } rval->ifile = ifile; fread( title, 84, 1, ifile); fseek( ifile, 2652L, SEEK_SET); /* skip title & constant name data */ fread( rval, JPL_HEADER_SIZE, 1, ifile); de_version = atoi( title + 26); /* Once upon a time, the kernel size was determined from the */ /* DE version. This was not a terrible idea, except that it */ /* meant that when the code faced a new version, it broke. */ /* Thus, the 'OLD_CODE' section was replaced with some logic */ /* that figures out the kernel size. The 'OLD_CODE' section */ /* should therefore be of only historical interest. */ #ifdef OLD_CODE switch( de_version) { case 200: case 202: rval->kernel_size = 1652; break; case 403: case 405: rval->kernel_size = 2036; break; case 404: case 406: rval->kernel_size = 1456; break; } #endif /* The 'iinfo' struct is right after the 'jpl_eph_data' struct: */ iinfo = (struct interpolation_info *)(rval + 1); rval->iinfo = (void *)iinfo; iinfo->np = 2; iinfo->nv = 3; iinfo->pc[0] = 1.0; iinfo->pc[1] = 0.0; iinfo->vc[1] = 1.0; rval->curr_cache_loc = -1L; /* The 'cache' data is right after the 'iinfo' struct: */ rval->cache = (double *)( iinfo + 1); /* A small piece of trickery: in the binary file, data is stored */ /* for ipt[0...11], then the ephemeris version, then the */ /* remaining ipt[12] data. A little switching is required to get */ /* the correct order. */ /* 2010-02-05 M.Keith Modified this so that it doesn't use array * incicies that are out of bounds, avoiding segfaults when * compiled with gcc -O2 */ rval->ipt[12][0] = rval->ipt[12][1]; rval->ipt[12][1] = rval->ipt[12][2]; rval->ipt[12][2] = rval->ephemeris_version; rval->ephemeris_version = de_version; rval->swap_bytes = ( rval->ncon < 0 || rval->ncon > 65536L); if( rval->swap_bytes) /* byte order is wrong for current platform */ { swap_double( &rval->ephem_start, 1); swap_double( &rval->ephem_end, 1); swap_double( &rval->ephem_step, 1); swap_long_integer( &rval->ncon); swap_double( &rval->au, 1); swap_double( &rval->emrat, 1); for( j = 0; j < 3; j++) for( i = 0; i < 13; i++) swap_long_integer( &rval->ipt[i][j]); } rval->kernel_size = 4; for( i = 0; i < 13; i++) rval->kernel_size += rval->ipt[i][1] * rval->ipt[i][2] * ((i == 11) ? 4 : 6); /* printf( "Kernel size = %d\n", rval->kernel_size); */ rval->recsize = rval->kernel_size * 4L; rval->ncoeff = rval->kernel_size / 2L; if( val) { fseek( ifile, rval->recsize, SEEK_SET); fread( val, (size_t)rval->ncon, sizeof( double), ifile); if( rval->swap_bytes) /* gotta swap the constants, too */ { swap_double( val, rval->ncon); } } if( nam) { fseek( ifile, 84L * 3L, SEEK_SET); /* just after the 3 'title' lines */ for( i = 0; i < (int)rval->ncon; i++) fread( nam[i], 6, 1, ifile); } /* the file gets closed in jpl_close_ephemeris */ return( rval); }
/***************************************************************************** ** jpl_state(ephem,et2,list,pv,nut,bary) ** ****************************************************************************** ** This subroutine reads and interpolates the jpl planetary ephemeris file ** ** ** ** Calling sequence parameters: ** ** ** ** Input: ** ** ** ** et2[] double, 2-element JED epoch at which interpolation ** ** is wanted. Any combination of et2[0]+et2[1] which falls ** ** within the time span on the file is a permissible epoch. ** ** ** ** a. for ease in programming, the user may put the ** ** entire epoch in et2[0] and set et2[1]=0.0 ** ** ** ** b. for maximum interpolation accuracy, set et2[0] = ** ** the most recent midnight at or before interpolation ** ** epoch and set et2[1] = fractional part of a day ** ** elapsed between et2[0] and epoch. ** ** ** ** c. as an alternative, it may prove convenient to set ** ** et2[0] = some fixed epoch, such as start of integration,** ** and et2[1] = elapsed interval between then and epoch. ** ** ** ** list 12-element integer array specifying what interpolation ** ** is wanted for each of the "bodies" on the file. ** ** ** ** list[i]=0, no interpolation for body i ** ** =1, position only ** ** =2, position and velocity ** ** ** ** the designation of the astronomical bodies by i is: ** ** ** ** i = 0: mercury ** ** = 1: venus ** ** = 2: earth-moon barycenter ** ** = 3: mars ** ** = 4: jupiter ** ** = 5: saturn ** ** = 6: uranus ** ** = 7: neptune ** ** = 8: pluto ** ** = 9: geocentric moon ** ** =10: nutations in longitude and obliquity ** ** =11: lunar librations (if on file) ** ** ** ** output: ** ** ** ** pv[][6] double array that will contain requested interpolated ** ** quantities. The body specified by list[i] will have its ** ** state in the array starting at pv[i][0] (on any given ** ** call, only those words in 'pv' which are affected by the ** ** first 10 'list' entries (and by list(11) if librations are ** ** on the file) are set. The rest of the 'pv' array ** ** is untouched.) The order of components in pv[][] is: ** ** pv[][0]=x,....pv[][5]=dz. ** ** ** ** All output vectors are referenced to the earth mean ** ** equator and equinox of epoch. The moon state is always ** ** geocentric; the other nine states are either heliocentric ** ** or solar-system barycentric, depending on the setting of ** ** global variables (see below). ** ** ** ** Lunar librations, if on file, are put into pv[10][k] if ** ** list[11] is 1 or 2. ** ** ** ** nut dp 4-word array that will contain nutations and rates, ** ** depending on the setting of list[10]. the order of ** ** quantities in nut is: ** ** ** ** d psi (nutation in longitude) ** ** d epsilon (nutation in obliquity) ** ** d psi dot ** ** d epsilon dot ** ** ** *****************************************************************************/ int DLL_FUNC jpl_state( void *ephem, const double et[2], const int list[12], double pv[][6], double nut[4], const int bary) { struct jpl_eph_data *eph = (struct jpl_eph_data *)ephem; int i,j, n_intervals; JPLlong nr; double prev_midnight, time_of_day; double *buf = eph->cache; double t[2],aufac; struct interpolation_info *iinfo = (struct interpolation_info *)eph->iinfo; /* ********** main entry point ********** */ if (et[1] >= 0.5) { prev_midnight = et[0] + 0.5; time_of_day = et[1] - 0.5; } else { prev_midnight = et[0] - 0.5; time_of_day = et[1] + 0.5; } /* s=et[0] - 0.5; prev_midnight = floor( s); */ /* time_of_day = s - prev_midnight; */ /* prev_midnight += 0.5; */ /* here prev_midnight contains last midnight before epoch desired (in JED: *.5) and time_of_day contains the remaining, fractional part of the epoch */ /* error return for epoch out of range */ if( et[0] < eph->ephem_start || et[0] > eph->ephem_end) return( -1); /* calculate record # and relative time in interval */ nr = (JPLlong)((prev_midnight-eph->ephem_start)/eph->ephem_step)+2; /* add 2 to adjus for the first two records containing header data */ if( prev_midnight == eph->ephem_end) nr--; t[0]=( prev_midnight-( (1.0*nr-2.0)*eph->ephem_step+eph->ephem_start) + time_of_day )/eph->ephem_step; /* read correct record if not in core (static vector buf[]) */ if( nr != eph->curr_cache_loc) { eph->curr_cache_loc = nr; fseek( eph->ifile, nr * eph->recsize, SEEK_SET); fread( buf, (size_t)eph->ncoeff, sizeof( double), eph->ifile); if( eph->swap_bytes) swap_double( buf, eph->ncoeff); } t[1] = eph->ephem_step; aufac = 1.0 / eph->au; for( n_intervals = 1; n_intervals <= 8; n_intervals *= 2) for( i = 0; i < 11; i++) if( n_intervals == eph->ipt[i][2] && (list[i] || i == 10)) { int flag = ((i == 10) ? 2 : list[i]); double *dest = ((i == 10) ? eph->pvsun : pv[i]); interp( iinfo, &buf[eph->ipt[i][0]-1], t, (int)eph->ipt[i][1], 3, n_intervals, flag, dest); /* gotta convert units */ for( j = 0; j < flag * 3; j++) dest[j] *= aufac; } if( !bary) /* gotta correct everybody for */ for( i = 0; i < 9; i++) /* the solar system barycenter */ for( j = 0; j < list[i] * 3; j++) pv[i][j] -= eph->pvsun[j]; /* do nutations if requested (and if on file) */ if(list[10] > 0 && eph->ipt[11][1] > 0) interp( iinfo, &buf[eph->ipt[11][0]-1], t, (int)eph->ipt[11][1], 2, (int)eph->ipt[11][2], list[10], nut); /* get librations if requested (and if on file) */ if(list[11] > 0 && eph->ipt[12][1] > 0) { double pefau[6]; interp( iinfo, &buf[eph->ipt[12][0]-1], t, (int)eph->ipt[12][1], 3, (int)eph->ipt[12][2], list[11], pefau); for( j = 0; j < 6; ++j) pv[10][j]=pefau[j]; } return( 0); }
void control_output(void) { Str_out_point *outs; U8_T point = 0; U32_T val; // U8_T loop; U32_T value; point = 0; outs = outputs; while( point < MAX_OUTS ) { if(point < get_max_output()) { #ifdef ASIX_CON if(point < get_max_internal_output()) { outs->sub_id = 0; outs->sub_product = 0; outs->sub_number = 0; outs->decom = 0; } else { outs->switch_status = 2/*SW_AUTO*/; } #endif #ifdef ARM_CON outs->decom = 0; #endif if( outs->range == not_used_output ) { outs->value = 0L; val = 0; } else { if(outs->switch_status == 0/*SW_OFF*/) { outs->value = 0L; outs->control = 0; //output_raw[point] = 0; set_output_raw(point,0); } else if(outs->switch_status == 2/*SW_HAND*/) { set_output_raw(point,1000);//output_raw[point] = 1000; outs->control = 1; switch( outs->range ) { case V0_10: outs->value = swap_double(10000); break; case P0_100_Open: case P0_100_Close: case P0_100: case P0_100_PWM: outs->value = swap_double(100000); break; case P0_20psi: case I_0_20ma: outs->value = swap_double(20000); break; default: val = 0; break; } } else { if( outs->digital_analog == 0 ) // digital_analog 0=digital 1=analog { // digtal input range if( outs->range >= OFF_ON && outs->range <= LOW_HIGH ) if( outs->control ) val = 1000; else val = 0; if( outs->range >= ON_OFF && outs->range <= HIGH_LOW ) if( outs->control ) val = 0; else val = 1000; if( outs->range >= custom_digital1 && outs->range <= custom_digital8 ) if( outs->control ) val = 1000; else val = 0; set_output_raw(point,val);//output_raw[point] = val; outs->value = swap_double(val); } else if( outs->digital_analog == 1 ) // analog { #ifdef ASIX_CON if(point < get_max_internal_output()) // internal output #endif { value = swap_double(outs->value); val = value; switch( outs->range ) { case V0_10: //outs->count = 10; set_output_raw(point, value * 100 / 1000);//output_raw[point] = value * 100 / 1000; break; case P0_100_Open: case P0_100_Close: case P0_100: case P0_100_PWM: //outs->count = 100; set_output_raw(point, value * 10 / 1000);//output_raw[point] = value * 10 / 1000; /* if( outs->m_del_low < outs->s_del_high ) { delta = outs->s_del_high - outs->m_del_low; value *= delta; value += (long)( outs->m_del_low * 100000L ); } else { delta = outs->m_del_low - outs->s_del_high; value *= delta; value += (long)( outs->s_del_high * 100000L ); } val = (Byte)( value * 213 / 10000000L );*/ break; case P0_20psi: case I_0_20ma: //outs->count = 20; set_output_raw(point, value * 50 / 1000);//output_raw[point] = value * 50 / 1000; break; default: val = 0; break; } //#if MINI // if(flag_output == ADJUST_AUTO) // { // if(output_raw_back[point] != output_raw[point]) // { // output_raw_back[point] = output_raw[point]; // AO_auto[point] = output_raw[point]; // } // } //#endif outs->value = swap_double(val); } #ifdef ASIX_CON else// external ouput { // range is 0-10v if(outs->read_remote == 1) { val = 10000000 / 4095; val = val * get_output_raw(point) / 1000; outs->read_remote = 0; } else { val = swap_double(outs->value); val = val * 4095 / 10000; // ????????? if(val < get_output_raw(point)) { if(get_output_raw(point) - val == 1) set_output_raw(point,val + 1);//output_raw[point] = val + 1; if(get_output_raw(point) - val == 2) set_output_raw(point,val + 2);//output_raw[point] = val + 2; } else set_output_raw(point,val);//output_raw[point] = val; } } #endif } } } #ifdef ASIX_CON map_extern_output(point); #endif } else { outs->sub_id = 0; outs->sub_product = 0; outs->sub_number = 0; outs->decom = 1; // no used } point++; outs++; } }
/** * Compute transient reachability probabilities in nonuniform CTMDPs. * * @param ctmdp CTMDP to compute probabilities for * @param rates vector of different rates occuring in CTMDP * @param num_rates size of rates vector * @param choices_to_rates maps choice numbers to corresponding rate index * @param k_bound maximal cardinality to consider * @ */ static double *ctmdpi_iterate (const NDSparseMatrix *ctmdp, const double *rates, const unsigned num_rates, const unsigned *choices_to_rates, const unsigned k_bound, const bitset *B, const double time_bound, const BOOL min) { double *probs_k; double *probs_km1; unsigned state_nr; double li; unsigned prob_nr; unsigned vec_nr; unsigned num_k_vecs; unsigned num_km1_vecs; unsigned *rates_quant; unsigned *all_k_rates_quant; unsigned *all_km1_rates_quant; unsigned k; const unsigned num_states = (unsigned) ctmdp->n; const unsigned max_entries = multiset_coeff(num_rates, k_bound); unsigned succ_nr; unsigned choice_nr; double choice_prob; double succ_prob; unsigned succ_vec_nr; const unsigned *row_starts = (unsigned *) ctmdp->row_counts; const unsigned *choice_starts = (unsigned *) ctmdp->choice_counts; unsigned rate_nr; double *non_zeros = ctmdp->non_zeros; hypoexp_t *hypoexp; unsigned *rate_to_succ_vec_nr; probs_k = malloc(max_entries * num_states * sizeof(double)); probs_km1 = malloc(max_entries * num_states * sizeof(double)); all_k_rates_quant = malloc(max_entries * num_rates * sizeof(unsigned)); all_km1_rates_quant = malloc(max_entries * num_rates * sizeof(unsigned)); enumerate_k_vectors(num_rates, k_bound, all_k_rates_quant, &num_k_vecs); hypoexp = init_hypoexp(k_bound, rates, num_rates, time_bound); rate_to_succ_vec_nr = malloc(num_rates * sizeof(unsigned)); compute_k_bound_probs(all_k_rates_quant, num_k_vecs, num_rates, hypoexp, k_bound, num_states, B, probs_k); for (k = k_bound; k > 0; k--) { enumerate_k_vectors(num_rates, k - 1, all_km1_rates_quant, &num_km1_vecs); prob_nr = 0; for (vec_nr = 0; vec_nr < num_km1_vecs; vec_nr++) { rates_quant = get_ith_vec(all_km1_rates_quant, vec_nr, num_rates); li = hypoexp_cumulate(rates_quant, k - 1, hypoexp); for (rate_nr = 0; rate_nr < num_rates; rate_nr++) { rates_quant[rate_nr] += 1; succ_vec_nr = vector_to_number (rates_quant, all_k_rates_quant, num_rates, 0, num_k_vecs-1); rates_quant[rate_nr] -= 1; rate_to_succ_vec_nr[rate_nr] = succ_vec_nr; } for (state_nr = 0; state_nr < num_states; state_nr++) { if (get_bit_val(B, state_nr)) { probs_km1[prob_nr] = li; } else { unsigned state_start = row_starts[state_nr]; unsigned state_end = row_starts[state_nr + 1]; double opt_choice_prob = min ? 2.0 : -1.0; for (choice_nr = state_start; choice_nr < state_end; choice_nr++) { unsigned choice_start = choice_starts[choice_nr]; unsigned choice_end = choice_starts[choice_nr + 1]; choice_prob = 0.0; rate_nr = choices_to_rates[choice_nr]; succ_vec_nr = rate_to_succ_vec_nr[rate_nr]; for (succ_nr = choice_start; succ_nr < choice_end; succ_nr++) { succ_prob = probs_k[succ_vec_nr * num_states + (ctmdp->cols)[succ_nr]]; choice_prob += non_zeros[succ_nr] * succ_prob; } opt_choice_prob = optimum(min, choice_prob, opt_choice_prob); } if (state_start == state_end) { opt_choice_prob = 0.0; } probs_km1[prob_nr] = opt_choice_prob; } prob_nr++; } } swap_double(&probs_k, &probs_km1); swap_unsigned(&all_k_rates_quant, &all_km1_rates_quant); num_k_vecs = num_km1_vecs; } free_hypoexp(hypoexp); free(probs_km1); free(all_k_rates_quant); free(all_km1_rates_quant); free(rate_to_succ_vec_nr); return probs_k; }