Word QepcadCls::ACCCVBCR(Word k, Word c, Word B1, Word b, Word* B1h) { Word d, nnf, dV, IV, cp, i, I_i, d_i, c_i, L, Q, Qb, Qbs, F, Fp, a; Step1: /* Initialization **********************************************/ a = NIL; /* this is the pseudo-sample point we're building up *******/ F = NIL; /* Useless now, could be usefull later. ********************/ d = 0; /* dimension of cell c_i. **********************************/ nnf = 0; /* number of variables not fixed. **************************/ dV = CINV(RED(PDEGV(k+1,B1))); /* vector of degrees of first k ****** variables of B1. ******************/ IV = LELTI(c,INDX); /* vector of indices of cell c. ******/ Step2: /* Loop over each level from 1 to k ****************************/ c_i = GVPC; for(i = 1; i <= k; i++) { I_i = LELTI(IV,i); d_i = LELTI(dV,i); c_i = LELTI(LELTI(c_i,CHILD),I_i); Step3: /* c_i is a section over a 0-dimensional cell ******************/ if ((I_i % 2 == 0) && d == 0) { a = SUFFIX(a,LELTI(b,i)); continue; } Step4: /* c_i is a section over a cell of dimension greater than zero */ if ((I_i % 2 == 0) && d > 0) { for(L=SECTIONPOLS(i,c_i,GVPF),Qbs=1,Fp=NIL; L != NIL; L=RED(L)) { Q = RPFIP(i,LELTI(FIRST(L),PO_POLY)); Qb = SPECIALSUBSR(i,a,Q); /* Qb can't be zero, by definition of SECTIONPOLS */ Qbs = RPEMV(nnf + 1,Qb,LELTI(b,i)); if (Qbs == 0) { a = SUFFIX(a,LELTI(b,i)); break; } else Fp = COMP(Qb,Fp); } if (L == NIL) { F = CCONC(F,Fp); nnf++; a = SUFFIX(a,NIL); } } Step5: /* c_i is a sector *********************************************/ if (I_i % 2 == 1) { d++; nnf++; a = SUFFIX(a,NIL); } } /*Step6: a is the psuedo-sample point, check that B1 is univariate at a. */ bool uniq = true; Word B1b = SPECIALSUBSR(k+1,a,RPFIP(k+1,B1)); for(Word B1s = B1b; uniq && B1s != 0; B1s = PRED(B1s)) uniq = IPCONST(nnf,PLDCF(B1s)); if (B1h != 0) *B1h = B1b; return uniq ? TRUE : UNDET; }
/* Initialize all the necessary variables, start the event loop, register readline, and stdin, start the loop. */ void cli_command_loop (void *data /* unused */) { int length; char *a_prompt; char *gdb_prompt = get_prompt (); /* If we are using readline, set things up and display the first prompt, otherwise just print the prompt. */ if (async_command_editing_p) { /* Tell readline what the prompt to display is and what function it will need to call after a whole line is read. This also displays the first prompt. */ length = strlen (PREFIX (0)) + strlen (gdb_prompt) + strlen (SUFFIX (0)) + 1; a_prompt = (char *) xmalloc (length); strcpy (a_prompt, PREFIX (0)); strcat (a_prompt, gdb_prompt); strcat (a_prompt, SUFFIX (0)); rl_callback_handler_install (a_prompt, input_handler); } else display_gdb_prompt (0); /* Now it's time to start the event loop. */ start_event_loop (); }
/* * Read the genotype for all the individuals in iidList at the SNP specified by iSNP * and store the results in pvOut */ void SUFFIX(CBedFile)::ReadGenotypes(size_t iSnp, bool count_A1, const vector< size_t >& idxIndividualList, REAL* pvOut, uint64_t_ startpos, uint64_t_ outputNumSNPs) { //fprintf(stdout,"reading iSnp=%d w/ cIndividuals=%d and startpos=%d\n",iSnp,cIndividuals,startpos); ReadLine( &rgBytes[0], iSnp ); // 'decompress' the genotype information size_t iIndividual = 0; for ( size_t ib = 0; ib < cbStride; ++ib ) { BYTE genotypeByte = rgBytes[ ib ]; // manually unrolled loop to decompress this byte if ( iIndividual < cIndividuals ) rgBedGenotypes[ iIndividual++ ] = (BedGenotype)( genotypeByte & 0x03); if ( iIndividual < cIndividuals ) rgBedGenotypes[ iIndividual++ ] = (BedGenotype)((genotypeByte >> 2) & 0x03); if ( iIndividual < cIndividuals ) rgBedGenotypes[ iIndividual++ ] = (BedGenotype)((genotypeByte >> 4) & 0x03); if ( iIndividual < cIndividuals ) rgBedGenotypes[ iIndividual++ ] = (BedGenotype)((genotypeByte >> 6) & 0x03); } for ( size_t i=0; i<idxIndividualList.size(); ++i ) { size_t idx = idxIndividualList[ i ]; //fprintf(stdout,"iSnp=%d, iIID=%d\n",iSnp,idx); #ifdef ORDERF uint64_t_ out_idx = startpos + i; #else uint64_t_ out_idx = startpos + i * outputNumSNPs; #endif if (count_A1) { pvOut[out_idx] = SUFFIX(mapBedGenotypeToRealAlleleCountA1)[rgBedGenotypes[idx]]; } else { pvOut[out_idx] = SUFFIX(mapBedGenotypeToRealAlleleNoCountA1)[rgBedGenotypes[idx]]; } } }
/** * go_accumulator_addl: (skip) **/ void SUFFIX(go_accumulator_add) (ACC *acc, DOUBLE x) { unsigned ui = 0, uj; g_return_if_fail (acc != NULL); for (uj = 0; uj < acc->partials->len; uj++) { DOUBLE y = g_array_index (acc->partials, DOUBLE, uj); DOUBLE hi, lo; if (SUFFIX(fabs)(x) < SUFFIX(fabs)(y)) { DOUBLE t = x; x = y; y = t; } hi = x + y; lo = y - (hi - x); if (lo != 0) { g_array_index (acc->partials, DOUBLE, ui) = lo; ui++; } x = hi; } g_array_set_size (acc->partials, ui + 1); g_array_index (acc->partials, DOUBLE, ui) = x; }
// Beta and LogBeta /// <summary>Computes the log beta function</summary> double SUFFIX(LogBeta)(REAL x, REAL y) { if (x <= 0.0 || y <= 0.0){ printf("LogBeta args must be > 0."); throw(1); } return SUFFIX(logGamma)(x) + SUFFIX(logGamma)(y) - SUFFIX(logGamma)(x + y); }
grub_err_t SUFFIX (grub_macho_readfile) (grub_macho_t macho, void *dest) { grub_ssize_t read; if (! SUFFIX (grub_macho_contains_macho) (macho)) return grub_error (GRUB_ERR_BAD_OS, "couldn't read architecture-specific part"); if (grub_file_seek (macho->file, macho->offsetXX) == (grub_off_t) -1) { grub_error_push (); return grub_error (GRUB_ERR_BAD_OS, "invalid offset in program header"); } read = grub_file_read (macho->file, dest, macho->endXX - macho->offsetXX); if (read != (grub_ssize_t) (macho->endXX - macho->offsetXX)) { grub_error_push (); return grub_error (GRUB_ERR_BAD_OS, "couldn't read architecture-specific part"); } return GRUB_ERR_NONE; }
void Rsuave(int *pndim, int *pncomp, void ** integrand, void *env, real *lower, real *upper, real *prdbounds, double *pepsrel, double *pepsabs, int *pmersenneseed, int *pflags, int *pmineval, int *pmaxeval, int *pnnew, double *pflatness, int *pnregions, int *pneval, int *pfail, double *integral, double *erreur, double *prob) { /* store the R function and its environment dans un global*/ rho= (SEXP)(env); globf= (SEXP)(integrand); lower_ = lower; upper_ = upper; prdbounds_ = *prdbounds; if (NA_INTEGER != *pmersenneseed) SUFFIX(mersenneseed)= *pmersenneseed; /* call suave */ suave((ccount *)pndim, (ccount *)pncomp, (Integrand)RIntegrand, (ctreal *)pepsrel, (ctreal *)pepsabs, (cint *)pflags, (cnumber *)pmineval, (cnumber *)pmaxeval, (cnumber *)pnnew, (ctreal *)pflatness, (count *) pnregions, (number *)pneval, (int *)pfail, (real *)integral, (real *)erreur, (real *)prob); } // End Rsuave
grub_size_t SUFFIX (grub_macho_filesize) (grub_macho_t macho) { if (SUFFIX (grub_macho_contains_macho) (macho)) return macho->endXX - macho->offsetXX; return 0; }
/* ___mkd_emblock() */ void ___mkd_emblock(MMIOT *f) { int i; block *p; for (i=0; i < S(f->Q); i++) { p = &T(f->Q)[i]; if ( p->b_type != bTEXT ) emmatch(f, i); if ( S(p->b_post) ) { SUFFIX(f->out, T(p->b_post), S(p->b_post)); DELETE(p->b_post); } if ( S(p->b_text) ) { SUFFIX(f->out, T(p->b_text), S(p->b_text)); DELETE(p->b_text); } } S(f->Q) = 0; }
// wrapper to be used from cython void SUFFIX(readPlinkBedFile)(std::string bed_fn, int inputNumIndividuals, int inputNumSNPs, bool count_A1, std::vector<size_t> individuals_idx, std::vector<int> snpIdxList, REAL* out) { uint64_t_ N = inputNumIndividuals; uint64_t_ outputNumSNPs = snpIdxList.size(); SUFFIX(CBedFile) bedFile = SUFFIX(CBedFile)(); bedFile.Open(bed_fn, inputNumIndividuals, inputNumSNPs); for (size_t i = 0; i != snpIdxList.size(); i++){ int idx = snpIdxList[i]; #ifdef ORDERF uint64_t_ startpos = ((uint64_t_)i) * individuals_idx.size(); #else uint64_t_ startpos = ((uint64_t_)i); #endif bedFile.ReadGenotypes(idx, count_A1, individuals_idx, out, startpos, outputNumSNPs); } }
/* reparse() into a cstring */ void Csreparse(Cstring *iot, char *buf, int size, int flags) { MMIOT f; ___mkd_initmmiot(&f, 0); ___mkd_reparse(buf, size, 0, &f, 0); ___mkd_emblock(&f); SUFFIX(*iot, T(f.out), S(f.out)); ___mkd_freemmiot(&f, 0); }
/* ___mkd_emblock() -- emblock a string of blocks, then concatenate the * resulting text onto f->out. */ void ___mkd_emblock(MMIOT *f) { int i; block *p; emblock(f, 0, S(f->Q)-1); for (i=0; i < S(f->Q); i++) { p = &T(f->Q)[i]; emfill(p); if ( S(p->b_post) ) { SUFFIX(f->out, T(p->b_post), S(p->b_post)); DELETE(p->b_post); } if ( S(p->b_text) ) { SUFFIX(f->out, T(p->b_text), S(p->b_text)); DELETE(p->b_text); } } S(f->Q) = 0; } /* ___mkd_emblock */
/// <summary>Probability distribution function</summary> /// <param name="x">Value at which to compute the pdf</param> /// <param name="a">Shape parameter (alpha)</param> /// <param name="b">Shape parameter (beta)</param> REAL SUFFIX(BetaPdf)(REAL x, REAL a, REAL b){ if (a <= 0 || b <= 0){ printf("Beta.Pdf parameters, a and b, must be > 0"); throw(1); } if (x > 1) return 0; if (x < 0) return 0; REAL lnb = SUFFIX(LogBeta)(a, b); return exp((a - 1) * log(x) + (b - 1) * log(1 - x) - lnb); }
/* Used when the user requests a different annotation level, with 'set annotate'. It pushes a new prompt (with prefix and suffix) on top of the prompt stack, if the annotation level desired is 2, otherwise it pops the top of the prompt stack when we want the annotation level to be the normal ones (1 or 0). */ static void change_annotation_level (void) { char *prefix, *suffix; if (!PREFIX (0) || !PROMPT (0) || !SUFFIX (0)) { /* The prompt stack has not been initialized to "", we are using gdb w/o the --async switch */ warning (_("Command has same effect as set annotate")); return; } if (annotation_level > 1) { if (!strcmp (PREFIX (0), "") && !strcmp (SUFFIX (0), "")) { /* Push a new prompt if the previous annotation_level was not >1. */ prefix = (char *) alloca (strlen (async_annotation_suffix) + 10); strcpy (prefix, "\n\032\032pre-"); strcat (prefix, async_annotation_suffix); strcat (prefix, "\n"); suffix = (char *) alloca (strlen (async_annotation_suffix) + 6); strcpy (suffix, "\n\032\032"); strcat (suffix, async_annotation_suffix); strcat (suffix, "\n"); push_prompt (prefix, (char *) 0, suffix); } } else { if (strcmp (PREFIX (0), "") && strcmp (SUFFIX (0), "")) { /* Pop the top of the stack, we are going back to annotation < 1. */ pop_prompt (); } } }
// Use GalenA's implementation of LogGamma - it's faster! /// <summary>Returns the log of the gamma function</summary> /// <param name="x">Argument of function</param> /// <returns>Log Gamma(x)</returns> /// <remarks>Accurate to eight digits for all x.</remarks> REAL SUFFIX(logGamma)(REAL x) { if (x <= (REAL)0.0){ printf("LogGamma arg=%f must be > 0.",x); throw(1); } REAL res = (REAL)0.0; if (x < (REAL)6.0) { int toAdd = (int)floor(7 - x); REAL v2 = (REAL)1.0; for (int i = 0; i < toAdd; i++) { v2 *= (x + i); } res = -log(v2); x += toAdd; } x -= (REAL)1.0; res += SUFFIX(_halflog2pi) + (x + (REAL)0.5) * log(x) - x; // correction terms REAL xSquared = x * x; REAL pow = x; for (int i=0; i<5; ++i) //the length of the coefficient array is 5. { REAL newRes = res + (REAL)1.0 / (SUFFIX(coeffsForLogGamma)[i] * pow); if (newRes == res) { return res; } res = newRes; pow *= xSquared; } return res; }
static void splitline(Line *t, int cutpoint) { if ( t && (cutpoint < S(t->text)) ) { Line *tmp = calloc(1, sizeof *tmp); tmp->next = t->next; t->next = tmp; tmp->dle = t->dle; SUFFIX(tmp->text, T(t->text)+cutpoint, S(t->text)-cutpoint); S(t->text) = cutpoint; } }
/* APPLE LOCAL begin Inform user about debugging optimized code */ void adjust_prompts_for_optimized_code (void) { /* Case 1: gdb_prompt_is_optimized == false. */ if (!gdb_prompt_is_optimized) { /* If we're inside optimized code AND the user wants to be told about it, append '[opt> ' to the prompt. Actually, create a second duplicate prompt, and append to that. This allows for easy removal later. */ if (dwarf2_inform_debugging_optimized_code && currently_inside_optimized_code) { char *old_prompt = get_prompt (); char *new_prompt; if (strstr (old_prompt, "[opt> ") == 0) { new_prompt = (char *) xmalloc (strlen (old_prompt) + 7); sprintf (new_prompt, "%s[opt> ", old_prompt); push_prompt ("", new_prompt, ""); xfree (new_prompt); } gdb_prompt_is_optimized = 1; } } /* Case 2: gdb_prompt_is_optimized == true. */ else if (gdb_prompt_is_optimized) { /* If we're not inside optimized code, or the user does not want to be told about it, pop the '[opt> ' version of the prompt from the prompt stack. */ if (!dwarf2_inform_debugging_optimized_code || !currently_inside_optimized_code) { if (the_prompts.top > 0 && strstr (PROMPT (0), "[opt> ") != 0) { xfree (PREFIX (0)); xfree (PROMPT (0)); xfree (SUFFIX (0)); the_prompts.top--; } gdb_prompt_is_optimized = 0; } } }
Word PCADCINDEX(Word c) { Word I,Ip,p,i; Step1: /* Get index of parent cell, and append index of c. */ i = LELTI(c,SC_INX); p = LELTI(c,SC_PAR); if (p == NIL) I = NIL; else { Ip = PCADCINDEX(p); I = SUFFIX(Ip,i); } Return: /* Prepare to return. */ return (I); }
/* Pushes a new prompt on the prompt stack. Each prompt has three parts: prefix, prompt, suffix. Usually prefix and suffix are empty strings, except when the annotation level is 2. Memory is allocated within savestring for the new prompt. */ void push_prompt (char *prefix, char *prompt, char *suffix) { the_prompts.top++; PREFIX (0) = savestring (prefix, strlen (prefix)); /* Note that this function is used by the set annotate 2 command. This is why we take care of saving the old prompt in case a new one is not specified. */ if (prompt) PROMPT (0) = savestring (prompt, strlen (prompt)); else PROMPT (0) = savestring (PROMPT (-1), strlen (PROMPT (-1))); SUFFIX (0) = savestring (suffix, strlen (suffix)); }
/* emmatch() -- match emphasis for a single emphasis token. */ static void emmatch(MMIOT *f, int first, int last) { block *start = &T(f->Q)[first]; int e, e2, match; switch (start->b_count) { case 2: if ( e = empair(f,first,last,match=2) ) break; case 1: e = empair(f,first,last,match=1); break; case 0: return; default: e = empair(f,first,last,1); e2= empair(f,first,last,2); if ( e2 >= e ) { e = e2; match = 2; } else match = 1; break; } if ( e ) { /* if we found emphasis to match, match it, recursively call * emblock to match emphasis inside the new html block, add * the emphasis markers for the block, then (tail) recursively * call ourself to match any remaining emphasis on this token. */ block *end = &T(f->Q)[e]; end->b_count -= match; start->b_count -= match; emblock(f, first, e); PREFIX(start->b_text, emtags[match-1].open, emtags[match-1].size-1); SUFFIX(end->b_post, emtags[match-1].close, emtags[match-1].size); emmatch(f, first, last); } } /* emmatch */
static inline grub_err_t read_headers (grub_file_t file, Elf_Ehdr *e, char **shdr) { if (grub_file_seek (file, 0) == (grub_off_t) -1) return grub_errno; if (grub_file_read (file, (char *) e, sizeof (*e)) != sizeof (*e)) { if (grub_errno) return grub_errno; else return grub_error (GRUB_ERR_BAD_OS, "file is too short"); } if (e->e_ident[EI_MAG0] != ELFMAG0 || e->e_ident[EI_MAG1] != ELFMAG1 || e->e_ident[EI_MAG2] != ELFMAG2 || e->e_ident[EI_MAG3] != ELFMAG3 || e->e_ident[EI_VERSION] != EV_CURRENT || e->e_version != EV_CURRENT) return grub_error (GRUB_ERR_BAD_OS, "invalid arch independent ELF magic"); if (e->e_ident[EI_CLASS] != SUFFIX (ELFCLASS)) return grub_error (GRUB_ERR_BAD_OS, "invalid arch dependent ELF magic"); *shdr = grub_malloc (e->e_shnum * e->e_shentsize); if (! *shdr) return grub_errno; if (grub_file_seek (file, e->e_shoff) == (grub_off_t) -1) return grub_errno; if (grub_file_read (file, *shdr, e->e_shnum * e->e_shentsize) != e->e_shnum * e->e_shentsize) { if (grub_errno) return grub_errno; else return grub_error (GRUB_ERR_BAD_OS, "file is truncated"); } return GRUB_ERR_NONE; }
/* Pops the top of the prompt stack, and frees the memory allocated for it. */ void pop_prompt (void) { /* If we are not during a 'synchronous' execution command, in which case, the top prompt would be empty. */ if (strcmp (PROMPT (0), "")) /* This is for the case in which the prompt is set while the annotation level is 2. The top prompt will be changed, but when we return to annotation level < 2, we want that new prompt to be in effect, until the user does another 'set prompt'. */ if (strcmp (PROMPT (0), PROMPT (-1))) { xfree (PROMPT (-1)); PROMPT (-1) = savestring (PROMPT (0), strlen (PROMPT (0))); } xfree (PREFIX (0)); xfree (PROMPT (0)); xfree (SUFFIX (0)); the_prompts.top--; }
#define HEAD_CRC 0x02 #define EXTRA_FIELD 0x04 #define ORIG_NAME 0x08 #define COMMENT 0x10 #define OS_CODE 3 /* Unix */ typedef struct { const char *zipped; int ziplen; const char *normal; /* for unzip - must not be longer than zipped */ } suffixes_t; static suffixes_t suffixes[] = { #define SUFFIX(Z, N) {Z, sizeof Z - 1, N} SUFFIX(GZ_SUFFIX, ""), /* Overwritten by -S .xxx */ #ifndef SMALL SUFFIX(GZ_SUFFIX, ""), SUFFIX(".z", ""), SUFFIX("-gz", ""), SUFFIX("-z", ""), SUFFIX("_z", ""), SUFFIX(".taz", ".tar"), SUFFIX(".tgz", ".tar"), #ifndef NO_BZIP2_SUPPORT SUFFIX(BZ2_SUFFIX, ""), #endif #ifndef NO_COMPRESS_SUPPORT SUFFIX(Z_SUFFIX, ""), #endif #ifndef NO_XZ_SUPPORT
* Include Files */ #include "CPlinkBedFileT.h" #include <iostream> #include <stdio.h> #include <math.h> #include <stdlib.h> // 0 and 2 are flipped (wrt C++ fastlmm) in order to agree to python code REAL SUFFIX(unknownOrMissing) = std::numeric_limits<REAL>::quiet_NaN(); // now used by SnpInfo REAL SUFFIX(homozygousPrimaryAllele) = 2; // Major Allele REAL SUFFIX(heterozygousAllele) = 1; REAL SUFFIX(homozygousSecondaryAllele) = 0; // Minor Allele () REAL SUFFIX(mapBedGenotypeToRealAllele)[4] = { SUFFIX(homozygousSecondaryAllele), // look-up 0 SUFFIX(unknownOrMissing), // look-up 1 SUFFIX(heterozygousAllele), // look-up 2 SUFFIX(homozygousPrimaryAllele), // look-up 3 }; SUFFIX(CBedFile)::SUFFIX(CBedFile)() { layout = LayoutUnknown; // layout describes the matrix layout on disk // 0=RowMajor(all snps per individual together); // 1=ColumnMajor(all individuals per SNP together in memory) cIndividuals = 0; cSnps = 0; cbStride = 0; }
static void emopen(Cstring *s, int level) { SUFFIX(*s, emtags[level-1].open, emtags[level-1].size-1); }
/** * go_accumulator_startl: (skip) **/ void * SUFFIX(go_accumulator_start) (void) { return SUFFIX(go_quad_start) (); }
grub_err_t SUFFIX (grub_freebsd_load_elfmodule) (struct grub_relocator *relocator, grub_file_t file, int argc, char *argv[], grub_addr_t *kern_end) { Elf_Ehdr e; Elf_Shdr *s; char *shdr = 0; grub_addr_t curload, module; grub_err_t err; grub_size_t chunk_size = 0; void *chunk_src; err = read_headers (file, &e, &shdr); if (err) return err; curload = module = ALIGN_PAGE (*kern_end); for (s = (Elf_Shdr *) shdr; s < (Elf_Shdr *) ((char *) shdr + e.e_shnum * e.e_shentsize); s = (Elf_Shdr *) ((char *) s + e.e_shentsize)) { if (s->sh_size == 0) continue; if (! (s->sh_flags & SHF_ALLOC)) continue; if (chunk_size < s->sh_addr + s->sh_size) chunk_size = s->sh_addr + s->sh_size; } if (chunk_size < sizeof (e)) chunk_size = sizeof (e); chunk_size += e.e_phnum * e.e_phentsize; chunk_size += e.e_shnum * e.e_shentsize; { grub_relocator_chunk_t ch; err = grub_relocator_alloc_chunk_addr (relocator, &ch, module, chunk_size); if (err) return err; chunk_src = get_virtual_current_address (ch); } for (s = (Elf_Shdr *) shdr; s < (Elf_Shdr *) ((char *) shdr + e.e_shnum * e.e_shentsize); s = (Elf_Shdr *) ((char *) s + e.e_shentsize)) { if (s->sh_size == 0) continue; if (! (s->sh_flags & SHF_ALLOC)) continue; grub_dprintf ("bsd", "loading section to %x, size %d, align %d\n", (unsigned) curload, (int) s->sh_size, (int) s->sh_addralign); switch (s->sh_type) { default: case SHT_PROGBITS: err = load (file, (grub_uint8_t *) chunk_src + module + s->sh_addr - *kern_end, s->sh_offset, s->sh_size); if (err) return err; break; case SHT_NOBITS: grub_memset ((grub_uint8_t *) chunk_src + module + s->sh_addr - *kern_end, 0, s->sh_size); break; } if (curload < module + s->sh_addr + s->sh_size) curload = module + s->sh_addr + s->sh_size; } load (file, UINT_TO_PTR (module), 0, sizeof (e)); if (curload < module + sizeof (e)) curload = module + sizeof (e); load (file, UINT_TO_PTR (curload), e.e_shoff, e.e_shnum * e.e_shentsize); e.e_shoff = curload - module; curload += e.e_shnum * e.e_shentsize; load (file, UINT_TO_PTR (curload), e.e_phoff, e.e_phnum * e.e_phentsize); e.e_phoff = curload - module; curload += e.e_phnum * e.e_phentsize; *kern_end = curload; grub_freebsd_add_meta_module (argv[0], FREEBSD_MODTYPE_ELF_MODULE, argc - 1, argv + 1, module, curload - module); return SUFFIX (grub_freebsd_load_elf_meta) (relocator, file, kern_end); }
/* * Parameters: * SNPs [nIndividuals by nSNPs]: * Matrix stored in column-major order. * This will hold the result. * NaNs will be set to 0.0 in the result. */ void SUFFIX(ImputeAndZeroMeanSNPs)( REAL *SNPs, const size_t nIndividuals, const size_t nSNPs, const bool betaNotUnitVariance, const REAL betaA, const REAL betaB ) { bool seenSNC = false; //Keep track of this so that only one warning message is reported #ifdef ORDERF for ( size_t iSnp = 0; iSnp < nSNPs; ++iSnp ) { REAL n_observed = 0.0; REAL sum_s = 0.0; //the sum of a SNP over all observed individuals REAL sum2_s = 0.0; //the sum of the squares of the SNP over all observed individuals size_t end = nIndividuals; size_t delta = 1; for( size_t ind = 0; ind < end; ind+=delta ) { if (SNPs[ind] == SNPs[ind]) { //check for not NaN sum_s += SNPs[ ind ]; sum2_s+= SNPs[ ind ] * SNPs[ ind ]; ++n_observed; } } if ( n_observed < 1.0 ) { printf( "No individual observed for the SNP.\n"); } REAL mean_s = sum_s / n_observed; //compute the mean over observed individuals for the current SNP REAL mean2_s = sum2_s / n_observed; //compute the mean of the squared SNP //When beta standardization is being done, check that data is 0,1,2 if (betaNotUnitVariance && sum_s <= (REAL)0.0) { REAL freqT = sum_s/n_observed; fprintf(stderr, "Observed SNP freq is %.2f. for a SNPs[:][%i]\n", freqT, iSnp ); exit(1); } //The SNP frequency REAL freq = (sum_s) / (n_observed * (REAL)2.0); //compute snp-freq as in the Visscher Height paper (Nat Gen, Yang et al 2010). if ((freq != freq) || betaNotUnitVariance && ((freq >= (REAL)1.0) || (freq <= (REAL)0.0))) { if (!seenSNC) { seenSNC = true; fprintf(stderr, "Illegal SNP frequency: %.2f for SNPs[:][%i]\n", freq, iSnp); } } REAL variance = mean2_s-mean_s * mean_s; //By the Cauchy Shwartz inequality this should always be positive REAL std = sqrt( variance ); //The SNP frequency bool isSNC = false; if ( (std != std) || (std <= (REAL)0.0) ) { // a std == 0.0 means all SNPs have the same value (no variation or Single Nucleotide Constant (SNC)) // however ALL SNCs should have been removed in previous filtering steps // This test now prevents a divide by zero error below std = 1.0; isSNC = true; if (!seenSNC) { seenSNC = true; fprintf(stderr, "std=.%2f has illegal value for SNPs[:][%i]\n", std, iSnp ); } } if (betaNotUnitVariance && freq > .5) { freq = 1.0 - freq; } for( size_t ind = 0; ind < end; ind+=delta ) { //check for NaN if ( (SNPs[ ind ]!=SNPs[ ind ]) || isSNC) { SNPs[ ind ] = 0.0; } else { SNPs[ ind ] -= mean_s; //subtract the mean from the data if (betaNotUnitVariance ) { REAL rT = SUFFIX(BetaPdf)( freq, betaA, betaB ); //fprintf(stderr, "BetaPdf(%f,%f,%f)=%f\n", freq, betaA, betaB, rT); SNPs[ ind ] *= rT; } else { SNPs[ ind ] /= std; //unit variance as well } } } SNPs += nIndividuals; } #else //Order C // Make one pass through the data (by individual, because that is how it is laid out), collecting statistics std::vector<REAL> n_observed(nSNPs); // C++ inits to 0's std::vector<REAL> sum_s(nSNPs); //the sum of a SNP over all observed individuals. C++ inits to 0's std::vector<REAL> sum2_s(nSNPs); //the sum of the squares of the SNP over all observed individuals. C++ inits to 0's for( size_t ind = 0; ind < nIndividuals; ++ind) { size_t rowStart = ind * nSNPs; for ( size_t iSnp = 0; iSnp < nSNPs; ++iSnp ) { REAL value = SNPs[rowStart+iSnp]; if ( value == value ) { sum_s[iSnp] += value; sum2_s[iSnp] += value * value; ++n_observed[iSnp]; } } } std::vector<REAL> mean_s(nSNPs); //compute the mean over observed individuals for the current SNP std::vector<REAL> mean2_s(nSNPs); //compute the mean of the squared SNP std::vector<REAL> std(nSNPs); //the standard deviation std::vector<REAL> freq(nSNPs); //The SNP frequency std::vector<bool> isSNC(nSNPs); // Is this a SNC (C++ inits to false) for ( size_t iSnp = 0; iSnp < nSNPs; ++iSnp ) { if ( n_observed[iSnp] < 1.0 ) { printf( "No individual observed for the SNP.\n"); } mean_s[iSnp] = sum_s[iSnp] / n_observed[iSnp]; //compute the mean over observed individuals for the current SNP mean2_s[iSnp] = sum2_s[iSnp] / n_observed[iSnp]; //compute the mean of the squared SNP //When beta standardization is being done, check that data is 0,1,2 if (betaNotUnitVariance && sum_s[iSnp] <= (REAL)0.0) { REAL freqT = sum_s[iSnp]/n_observed[iSnp]; fprintf(stderr, "Observed SNP freq is %.2f. for a SNPs[:][%i]\n", freqT, iSnp ); exit(1); } freq[iSnp] = (sum_s[iSnp]) / (n_observed[iSnp] * (REAL)2.0); //compute snp-freq[iSnp] as in the Visscher Height paper (Nat Gen, Yang et al 2010). if ((freq[iSnp] != freq[iSnp]) || betaNotUnitVariance && ((freq[iSnp] >= (REAL)1.0) || (freq[iSnp] <= (REAL)0.0))) { if (!seenSNC) { seenSNC = true; fprintf(stderr, "Illegal SNP frequency: %.2f for SNPs[:][%i]\n", freq[iSnp], iSnp); } } REAL variance = mean2_s[iSnp]-mean_s[iSnp] * mean_s[iSnp]; //By the Cauchy Shwartz inequality this should always be positive std[iSnp] = sqrt( variance ); if ( (std[iSnp] != std[iSnp]) || (std[iSnp] <= (REAL)0.0) ) { // a std == 0.0 means all SNPs have the same value (no variation or Single Nucleotide Constant (SNC)) // however ALL SNCs should have been removed in previous filtering steps // This test now prevents a divide by zero error below std[iSnp] = 1.0; isSNC[iSnp] = true; if (!seenSNC) { seenSNC = true; fprintf(stderr, "std=.%2f has illegal value for SNPs[:][%i]\n", std[iSnp], iSnp ); } } if (betaNotUnitVariance && freq[iSnp] > .5) { freq[iSnp] = 1.0 - freq[iSnp]; } } for( size_t ind = 0; ind < nIndividuals; ++ind) { size_t rowStart = ind * nSNPs; for ( size_t iSnp = 0; iSnp < nSNPs; ++iSnp ) { REAL value = SNPs[rowStart+iSnp]; //check for NaN if ( (value != value) || isSNC[iSnp]) { value = 0.0; } else { value -= mean_s[iSnp]; //subtract the mean from the data if (betaNotUnitVariance ) { REAL rT = SUFFIX(BetaPdf)( freq[iSnp], betaA, betaB ); //fprintf(stderr, "BetaPdf(%f,%f,%f)=%f\n", freq, betaA, betaB, rT); value *= rT; } else { value /= std[iSnp]; //unit variance as well } } SNPs[rowStart+iSnp] = value; } } #endif }
/* Displays the prompt. The prompt that is displayed is the current top of the prompt stack, if the argument NEW_PROMPT is 0. Otherwise, it displays whatever NEW_PROMPT is. This is used after each gdb command has completed, and in the following cases: 1. when the user enters a command line which is ended by '\' indicating that the command will continue on the next line. In that case the prompt that is displayed is the empty string. 2. When the user is entering 'commands' for a breakpoint, or actions for a tracepoint. In this case the prompt will be '>' 3. Other???? FIXME: 2. & 3. not implemented yet for async. */ void display_gdb_prompt (char *new_prompt) { int prompt_length = 0; char *gdb_prompt = get_prompt (); static int stdin_handler_removed = 0; /* APPLE LOCAL begin Inform user about debugging optimized code */ if (strcmp (gdb_prompt, "") != 0) { adjust_prompts_for_optimized_code (); gdb_prompt = get_prompt (); } /* APPLE LOCAL end Inform user about debugging optimized code */ /* Each interpreter has its own rules on displaying the command prompt. */ if (!current_interp_display_prompt_p ()) return; if (target_executing && sync_execution) { /* This is to trick readline into not trying to display the prompt. Even though we display the prompt using this function, readline still tries to do its own display if we don't call rl_callback_handler_install and rl_callback_handler_remove (which readline detects because a global variable is not set). If readline did that, it could mess up gdb signal handlers for SIGINT. Readline assumes that between calls to rl_set_signals and rl_clear_signals gdb doesn't do anything with the signal handlers. Well, that's not the case, because when the target executes we change the SIGINT signal handler. If we allowed readline to display the prompt, the signal handler change would happen exactly between the calls to the above two functions. Calling rl_callback_handler_remove(), does the job. */ delete_file_handler (input_fd); stdin_handler_removed = 1; rl_callback_handler_remove (); return; } if (!new_prompt) { /* Just use the top of the prompt stack. */ prompt_length = strlen (PREFIX (0)) + strlen (SUFFIX (0)) + strlen (gdb_prompt) + 1; new_prompt = (char *) alloca (prompt_length); /* Prefix needs to have new line at end. */ strcpy (new_prompt, PREFIX (0)); strcat (new_prompt, gdb_prompt); /* Suffix needs to have a new line at end and \032 \032 at beginning. */ strcat (new_prompt, SUFFIX (0)); } if (async_command_editing_p) { /* Claim the terminal before we reset it. It is quick if the terminal is already ours, and if not, we are going to lose when we try to install the callback handler otherwise. We can get here with the terminal still belonging to the inferior if it dies an unexpected death, and somebody forgets to clean up properly. Better safe than sorry... */ target_terminal_ours (); if (stdin_handler_removed) { add_file_handler (input_fd, stdin_event_handler, 0); stdin_handler_removed = 0; } rl_callback_handler_remove (); rl_callback_handler_install (new_prompt, input_handler); } /* new_prompt at this point can be the top of the stack or the one passed in */ else if (new_prompt) { /* Don't use a _filtered function here. It causes the assumed character position to be off, since the newline we read from the user is not accounted for. */ fputs_unfiltered (new_prompt, gdb_stdout); gdb_flush (gdb_stdout); } }
void SUFFIX(go_accumulator_end) (void *state) { SUFFIX(go_quad_end) (state); }