FUNCTION CODE rrange ( TEXT string[], /* integer range string */ TAEFLOAT *rlow, /* out: lower value */ TAEFLOAT *rhigh /* out: high value */ ) { COUNT i; TEXT lstring[STRINGSIZ+1]; TAEFLOAT rtemp; *rlow = *rhigh = 0; /* init incase error */ s_copy(string, lstring); /* local copy */ i = s_index(string, ':'); if (i < 0) /* if no colon present */ { if (s_s2r(lstring, rlow) != SUCCESS) return (FAIL); *rhigh = *rlow; } else { if (s_s2r(&(lstring[i+1]), rhigh) != SUCCESS) return (FAIL); lstring[i] = EOS; /* terminate at colon */ if (s_s2r(lstring, rlow) != SUCCESS) return(FAIL); if (*rlow > *rhigh) /* reverse if out of order */ { rtemp = *rlow; *rlow = *rhigh; *rhigh = rtemp; } } return (SUCCESS); }
void CNPLCM_CR_Basic_Freq::permute_latent_classes_by_nu(){ //reorder latent classes increasingly according to nuK. std::vector<int> new2old(par->K), old2new(par->K); std::vector<_CNPLCM_CR_Basic_Freq_mypair> s_index(par->K); for (int k = 0; k < par->K; k++){ s_index[k].first = 1.0 - par->nuK[k]; s_index[k].second = k; } std::sort(s_index.begin(), s_index.end(), _CNPLCM_CR_Basic_Freq_comparator); std::vector<int> perm(K); for (int k = 0; k < par->K; k++){ new2old[k] = s_index[k].second; } // new2old[a] == b <=> former b-th element is now a-th element. for (int k = 0; k < par->K; k++){ old2new[ new2old[k] ] = k; } CParams_NPLCM_CR_Basic_Freq *tmp = new CParams_NPLCM_CR_Basic_Freq(*par); //for (int i = 0; i < par->n; i++){ // tmp->zI[i] = old2new[ par->zI[i] ]; //} for (int m = 0; m < par->M; m++){ for (int k = 0; k < par->K; k++){ tmp->count_zIK[m][k] = par->count_zIK[m][ new2old[k] ]; } } for (int j = 0; j < par->J; j++){ for (int k = 0; k < par->K; k++){ tmp->lambdaJK[j][k] = par->lambdaJK[j][ new2old[k] ]; tmp->aux_JK2[j][k][0] = par->aux_JK2[j][ new2old[k] ][0]; tmp->aux_JK2[j][k][1] = par->aux_JK2[j][ new2old[k] ][1]; } } for (int k = 0; k < par->K; k++){ tmp->nuK[k] = par->nuK[new2old[k]]; tmp->log_nuK[k] = par->log_nuK[new2old[k]]; tmp->countK[k] = par->countK[new2old[k]]; tmp->count0K[k] = par->count0K[new2old[k]]; } //std::copy(tmp->zI, tmp->zI + par->n, par->zI); std::copy(tmp->count_zIK[0], tmp->count_zIK[0] + par->M * par->J, par->count_zIK[0]); std::copy(tmp->lambdaJK[0], tmp->lambdaJK[0] + par->J * par->K, par->lambdaJK[0]); std::copy(tmp->aux_JK2[0][0], tmp->aux_JK2[0][0] + par->J * par->K * 2, par->aux_JK2[0][0]); std::copy(tmp->nuK, tmp->nuK + par->K, par->nuK); std::copy(tmp->log_nuK, tmp->log_nuK + par->K, par->log_nuK); std::copy(tmp->countK, tmp->countK + par->K, par->countK); std::copy(tmp->count0K, tmp->count0K + par->K, par->count0K); delete tmp; }
bool ParserColumnAndIndexDeclaraion::parseImpl(Pos & pos, ASTPtr & node, Expected & expected) { ParserKeyword s_index("INDEX"); ParserIndexDeclaration index_p; ParserColumnDeclaration column_p; ASTPtr new_node = nullptr; if (s_index.ignore(pos, expected)) { if (!index_p.parse(pos, new_node, expected)) return false; } else { if (!column_p.parse(pos, new_node, expected)) return false; } node = new_node; return true; }
/* Co_FindIt. Find object by name. Same as Co_Find, except returns * collection type as well. Inheritance would have been * nice here! * * This handles composite names, i.e. when a collection is * a collection of collections. * * For example, if given "A.B", Co_Find * would find the the collection object "A" and then find the * object "B" within "A". If somewhere along the line, * the object type is C_VM, then we call Vm_Find to * find the rest of the name. * */ struct OBJECT_INFO /* for comm to callback function thru Co_ForEach */ { CODE type; /* output of searchIt*/ TEXT *name; /* input to searchIt*/ BOOL first; /* input to searchIt*/ }; #define C_COLLECTION 0xcccc /* type of collect object */ #define C_VM 0xaaaa /* type of Vm object */ UNSUPPORTED Id Co_FindIt ( Id colid, /* in: collection id */ TEXT name[], /* in: name to find */ CODE *type /* out: type of collection */ ) { TEXT loc_name[STRINGSIZ+1]; Id object; struct OBJECT_INFO objectInfo; /* context block */ COUNT period; s_bcopy (name, loc_name, STRINGSIZ); /* local copy */ period = s_index (loc_name, '.'); /* composite name? */ if (period >= 0) loc_name[period] = EOS; /* clip at first name */ objectInfo.name = loc_name; object = (Id) Co_ForEach ((struct COLLECTION*) colid, searchIt, (GENPTR) &objectInfo); *type = objectInfo.type; if (period < 0 || object == NULL) /* if simple name... */ return (object); /* finished */ if (objectInfo.type == C_VM) return ((Id)Vm_Find (object, &loc_name[period+1])); else if (objectInfo.type == C_COLLECTION) { // This is actually *broken* on 64-bit systems, a 32 bit // integer can't be cast to a 64 bit pointer. Leave this // in place to get a clean compile, but trigger an error // if this is actually called. printf("Calling a broken function. This can't be fixed on a 64 bit system"); abort(); // return (Co_FindIt (object, &loc_name[period+1], *type)); } else return (NULL); }
FUNCTION CODE old_Co_ReadFile ( Id c, /* in: existing collection */ TEXT *filespec, /* in: name of file to read */ CODE mode /* in: mode for the vm objs */ ) { struct SFILE f; union { struct PARHDR ph; /* standard header */ TEXT padding[300]; /* in case reading new file */ } headBuffer; CODE code; COUNT recsize; Id vm; TEXT record [STRINGSIZ+2]; BOOL archive; TEXT fullSpec[STRINGSIZ+1]; struct FSBLOCK fsblock; /* to dig out file name */ TEXT errstr[STRINGSIZ+1]; COUNT islash; #ifdef UNIX union { TEXT record [STRINGSIZ+1]; /* padding for long records */ struct ar_hdr header; /* the real archive header */ } hdrRecord; #endif code = f_opnspc (&f, 1, filespec, "", "", "res", F_READ); if (code != SUCCESS) { x_error(mode, "Unable to open resource file '%s'. %s.", "TAE-PFOPN", (uintptr_t)filespec, (uintptr_t)f.errmsg, 0); return (FAIL); } /* determine whether file is concatenated or archive format */ code = f_read (&f, record); if (code == SUCCESS && s_equal (record, AR_SENTINEL)) archive = TRUE; else { archive = FALSE; f_rewind (&f); /* re-start at beginning */ } /* read each Vm object from the file */ while (FOREVER) { if (archive) /* skip header */ { #ifdef UNIX code = f_read (&f, (TEXT *)&hdrRecord); /* read hdr or pad */ if (code == SUCCESS && hdrRecord.record[0] == EOS) code = f_read (&f, (TEXT *)&hdrRecord); /* skip EOF padding */ if (code == F_EOF) { code = SUCCESS; break; } else if (code != SUCCESS) { f_close(&f, F_KEEP); x_error (mode, "File '%s' not correctly formatted.", "TAE-RESFORMAT", (uintptr_t)filespec, 0, 0); return (FAIL); } #ifdef AIX s_bcopy (hdrRecord.header._ar_name.ar_name, fullSpec, sizeof(hdrRecord.header._ar_name.ar_name)); #else s_bcopy (hdrRecord.header.ar_name, fullSpec, sizeof(hdrRecord.header.ar_name)); #endif s_strip (fullSpec); /* remove trailing blanks */ islash = s_index (fullSpec, '/'); /* HP (and others?) */ if (islash >= 0) /* term with slash */ fullSpec[islash] = EOS; /* clip at slash */ f_crack (fullSpec, "", "", "", &fsblock, errstr); /* dig name */ #else x_error (mode, "File '%s' not correctly formatted.", "TAE-RESFORMAT", filespec, 0, 0); return (FAIL); #endif } code = f_bread (&f, (GENPTR)&headBuffer, sizeof (headBuffer), &recsize); if (code == F_EOF) { code = SUCCESS; /* normal end-of-file */ break; } else if (code == SUCCESS && s_equal (headBuffer.ph.sentinel, "<<new par-file>>")) { f_close(&f, F_KEEP); x_error(mode, "Resource file '%s' has already been converted.", "TAE-VNEWFORMAT", (uintptr_t)filespec, 0, 0); return (FAIL); } else if(code != SUCCESS || !s_equal(headBuffer.ph.sentinel, P_SENTINEL)) { f_close(&f, F_KEEP); x_error(mode, "Error reading resource file '%s'. %s.", "TAE-PFRD", (uintptr_t)filespec, (uintptr_t)f.errmsg, 0); return (FAIL); } vm = Vm_New (mode); /* create new vm object */ code = Vm_ReadVm ((struct VM_STRUCT *)vm, &f); /* read parblk records */ if (code != SUCCESS) break; /* x_error already called */ if (archive) old_Co_Add ((struct COLLECTION *)c, vm, fsblock.name, C_VM); else old_Co_Add ((struct COLLECTION *)c, vm, headBuffer.ph.filename, C_VM); } f_close (&f, F_KEEP); return (code); }