void logconestw ( double *y_in,
double *xdata_in,
int *d_in,
int *n_in,
double *weights_in,
double *opt_out,
double *sigmavalue_out,
double *Jtol_in,
char **chopts_in,
int *nouter_in)
{
/* Initialise */
truepoints = *n_in;
dim = *d_in;
xdata = xdata_in;
nouter = *nouter_in;
npoints = truepoints + nouter;
weights = weights_in;
Jtol = *Jtol_in;
chopts = *chopts_in;
/* Use the solvoptweights */
*sigmavalue_out=solvoptweights(truepoints,y_in,&sigmaeffw,&subgradeffw,opt_out,&dnull_entry,&null_entry);
renormalise(y_in);
/*That's all!*/
}
static int load_wavefront_obj(const char *modelname, WAVEFRONT_MODEL_T *model, struct wavefront_model_loading_s *m)
{
char line[256+1];
unsigned short pp[54+1];
FILE *fp;
int i, valid;
float *qv = (float *)m->data;
float *qt = (float *)m->data + 3 * MAX_VERTICES;
float *qn = (float *)m->data + (3+2) * MAX_VERTICES;
unsigned short *qf = (unsigned short *)((float *)m->data + (3+2+3) * MAX_VERTICES);
float *pv = qv, *pt = qt, *pn = qn;
unsigned short *pf = qf;
fp = fopen(modelname, "r");
if (!fp) return -1;
m->num_materials = 0;
m->material_index[0] = 0;
valid = fread(line, 1, sizeof(line)-1, fp);
while (valid > 0) {
char *s, *end = line;
while((end-line < valid) && *end != '\n' && *end != '\r')
end++;
*end++ = 0;
if((end-line < valid) && *end != '\n' && *end != '\r')
*end++ = 0;
s = line;
if (s[strlen(s)-1] == 10) s[strlen(s)-1]=0;
switch (s[0]) {
case '#': break; // comment
case '\r': case '\n': case '\0': break; // blank line
case 'm': vc_assert(strncmp(s, "mtllib", sizeof "mtllib"-1)==0); break;
case 'o': break;
case 'u':
if (sscanf(s, "usemtl %s", /*MAX_MATERIAL_NAME-1, */model->material[m->num_materials].name) == 1) {
if (m->num_materials < MAX_MATERIALS) {
if (m->num_materials > 0 && ((pf-qf)/3 == m->material_index[m->num_materials-1] || strcmp(model->material[m->num_materials-1].name, model->material[m->num_materials].name)==0)) {
strcpy(model->material[m->num_materials-1].name, model->material[m->num_materials].name);
m->num_materials--;
} else
m->material_index[m->num_materials] = (pf-qf)/3;
m->num_materials++;
}
} else { printf("%s", s); vc_assert(0); }
break;
case 'g': vc_assert(strncmp(s, "g ", sizeof "g "-1)==0); break;
case 's': vc_assert(strncmp(s, "s ", sizeof "s "-1)==0); break;
case 'v': case 'f':
if (sscanf(s, "v %f %f %f", pv+0, pv+1, pv+2) == 3) {
pv += 3;
} else if (sscanf(s, "vt %f %f", pt+0, pt+1) == 2) {
pt += 2;
} else if (sscanf(s, "vn %f %f %f", pn+0, pn+1, pn+2) == 3) {
pn += 3;
} else if (i = sscanf(s, "f"" %hu//%hu %hu//%hu %hu//%hu %hu//%hu %hu//%hu %hu//%hu"
" %hu//%hu %hu//%hu %hu//%hu %hu//%hu %hu//%hu %hu//%hu"
" %hu//%hu %hu//%hu %hu//%hu %hu//%hu %hu//%hu %hu//%hu %hu",
pp+ 0, pp+ 1, pp+ 2, pp+ 3, pp+ 4, pp+ 5, pp+ 6, pp+ 7, pp+ 8, pp+ 9, pp+10, pp+11,
pp+12, pp+13, pp+14, pp+15, pp+16, pp+17, pp+18, pp+19, pp+20, pp+21, pp+22, pp+23,
pp+24, pp+25, pp+26, pp+27, pp+28, pp+29, pp+30, pp+32, pp+32, pp+33, pp+34, pp+35, pp+36), i >= 6) {
int poly = i/2;
//vc_assert(i < countof(pp)); // may need to increment poly count and pp array
for (i=1; i<poly-1; i++) {
*pf++ = pp[0]; *pf++ = 0; *pf++ = pp[1];
*pf++ = pp[2*i+0]; *pf++ = 0; *pf++ = pp[2*i+1];
*pf++ = pp[2*(i+1)+0]; *pf++ = 0; *pf++ = pp[2*(i+1)+1];
}
} else if (i = sscanf(s, "f"" %hu/%hu %hu/%hu %hu/%hu %hu/%hu %hu/%hu %hu/%hu"
" %hu/%hu %hu/%hu %hu/%hu %hu/%hu %hu/%hu %hu/%hu"
" %hu/%hu %hu/%hu %hu/%hu %hu/%hu %hu/%hu %hu/%hu %hu",
pp+ 0, pp+ 1, pp+ 2, pp+ 3, pp+ 4, pp+ 5, pp+ 6, pp+ 7, pp+ 8, pp+ 9, pp+10, pp+11,
pp+12, pp+13, pp+14, pp+15, pp+16, pp+17, pp+18, pp+19, pp+20, pp+21, pp+22, pp+23,
pp+24, pp+25, pp+26, pp+27, pp+28, pp+29, pp+30, pp+32, pp+32, pp+33, pp+34, pp+35, pp+36), i >= 6) {
int poly = i/2;
//vc_assert(i < countof(pp); // may need to increment poly count and pp array
for (i=1; i<poly-1; i++) {
*pf++ = pp[0]; *pf++ = pp[1]; *pf++ = 0;
*pf++ = pp[2*i+0]; *pf++ = pp[2*i+1]; *pf++ = 0;
*pf++ = pp[2*(i+1)+0]; *pf++ = pp[2*(i+1)+1]; *pf++ = 0;
}
} else if (i = sscanf(s, "f"" %hu/%hu/%hu %hu/%hu/%hu %hu/%hu/%hu %hu/%hu/%hu %hu/%hu/%hu %hu/%hu/%hu"
" %hu/%hu/%hu %hu/%hu/%hu %hu/%hu/%hu %hu/%hu/%hu %hu/%hu/%hu %hu/%hu/%hu"
" %hu/%hu/%hu %hu/%hu/%hu %hu/%hu/%hu %hu/%hu/%hu %hu/%hu/%hu %hu/%hu/%hu %hu",
pp+ 0, pp+ 1, pp+ 2, pp+ 3, pp+ 4, pp+ 5, pp+ 6, pp+ 7, pp+ 8, pp+ 9, pp+10, pp+11, pp+12, pp+13, pp+14, pp+15, pp+16, pp+17,
pp+18, pp+19, pp+20, pp+21, pp+22, pp+23, pp+24, pp+25, pp+26, pp+27, pp+28, pp+29, pp+30, pp+32, pp+32, pp+33, pp+34, pp+35,
pp+36, pp+37, pp+38, pp+39, pp+40, pp+41, pp+42, pp+43, pp+44, pp+45, pp+46, pp+47, pp+48, pp+49, pp+50, pp+51, pp+52, pp+53, pp+54), i >= 9) {
int poly = i/3;
//vc_assert(i < countof(pp); // may need to increment poly count and pp array
for (i=1; i<poly-1; i++) {
*pf++ = pp[0]; *pf++ = pp[1]; *pf++ = pp[2];
*pf++ = pp[3*i+0]; *pf++ = pp[3*i+1]; *pf++ = pp[3*i+2];
*pf++ = pp[3*(i+1)+0]; *pf++ = pp[3*(i+1)+1]; *pf++ = pp[3*(i+1)+2];
}
} else { printf("%s", s); vc_assert(0); }
break;
default:
printf("%02x %02x %s", s[0], s[1], s); vc_assert(0); break;
}
// shift down read characters and read some more into the end
// if we didn't find a newline, then end is one off the end of our
// line, so end-line will be valid+1
i = end-line > valid ? valid : end-line;
memmove(line, end, valid - i);
valid -= i;
valid += fread(line+valid, 1, sizeof(line)-1-valid, fp);
}
fclose(fp);
if (m->num_materials==0) m->material_index[m->num_materials++] = 0;
centre_and_rescale(qv, (pv-qv)/3);
renormalise(qn, (pn-qn)/3);
//centre_and_rescale2(qt, (pt-qt)/2);
m->numv = pv-qv;
m->numt = pt-qt;
m->numn = pn-qn;
m->numf = pf-qf;
// compress array
//memcpy((float *)m->data, (float *)m->data, m->numv * sizeof *qv); - nop
memcpy((float *)m->data + m->numv, (float *)m->data + 3 * MAX_VERTICES, m->numt * sizeof *qt);
memcpy((float *)m->data + m->numv + m->numt,(float *) m->data + (3 + 2) * MAX_VERTICES, m->numn * sizeof *qn);
memcpy((float *)m->data + m->numv + m->numt + m->numn, (float *)m->data + (3 + 2 + 3) * MAX_VERTICES, m->numf * sizeof *qf);
return 0;
}
// Methode d'apprentissage d'un PRFA prefixe
RESULT
PPRFA::DEES (T_ModeVariables modeVariables,
Sample & S,
double prec,
double epsprime,
bool verbose,
T_ModeReturn moderet,
T_ModeEpsilon modeeps,
unsigned int maxstates,
unsigned int seuil,
int maxmots,
int maxsearches,
bool bestsearch,
bool stepssave)
{
try {
// ------------------------- affichage des informations ---------------------- //
if (verbose)
{
cout << "\t\t=== DEES ===";
cout << "\nSample size = " << S.size ();
cout << "\nprecision = " << prec;
cout << "\nbound = " << epsprime;
cout << "\nmoderet = ";
switch (moderet)
{
case ::begin:
cout << "begin";
break;
case ::end:
cout << "end";
}
cout << "\nmodeeps = ";
switch (modeeps)
{
case epsfixed:
cout << "epsfixed";
break;
case variable:
cout << "variable";
break;
case word_variable:
cout << "word_variable";
break;
}
cout << "\nmaxstates = " << maxstates;
cout << "\nseuil = " << seuil;
cout << "\nmaxmots = " << maxmots << endl;
}
if (prec == 0) {
return becomePrefixTree(S);
}
// -------------------------- INITIALISATION ----------------------
vide (); // on initialise le PFA.
if (S.size () == 0)
throw 0; // on verifie que l'echantillon n'est pas vide.
S.prefixialise (); // Transformation de l'Èchantillon en echantillon prefixiel.
Sigma = S.alphabet (); // on met ‡† jour l'alphabet
alph = S.dictionnaire (); // et le dictionnaire associÈ.
// Declaration
Word v; // the word v which represent the word associated to the state to add.
list < Word > X; // The set of words which are potential prime residuals.
Sample::const_iterator u; // current word of the sample.
float val; // a floating value used to calculate tau.
Word w; // a word
Word ww; // another word
Lettre a; // a letter (we will have v=wa)
Alphabet::const_iterator b; // pour enumerer toutes les lettres
SFunc solution; // the system solution
SFunc solutiontemp; // a temporary solution
StateSet::iterator q; // Pour enumerer les états
Simplex simplx; // L'objet simplexe qui contient les algorithmes de resolution de systemes.
set < Word, ordre_mot > W; // L'ensemble de mots à tester
Word::iterator z; // last letter
// --- init variables ---
v.clear (); // v = epsilon (empty word)
// X is the set of one letter words of S when prefixialised
val = 0;
for (u = ++(S.begin ());
(u != S.end ()) && (u->first.size () < 2); ++u)
{
X.push_back (u->first);
val += u->second;
}
// We create the first state (epsilon)
addState (v, 1, 1 - (float(val) / float(S.size ())));
W.clear ();
// liste_mots_associes(W,v,S,maxmots);
ajoute_mots_associes(W,v,S,maxmots);
// There may be a general state
State generalstate = -1;
// Step saving
string svgfile="etape-";
// -------------------------- LEARNING LOOP -----------------------
if (verbose)
cout << "Ajout des états : " << endl;
// For each element in X (the temporary list)
while (!X.empty ())
{
v = *(X.begin ()); // v <-- min X;
X.pop_front (); // X <-- X\{v} ;
// wa=v
w = v;
a = *(w.rbegin ());
z = w.end ();
--z;
w.erase (z); //w.pop_back ();
//~ if (verbose) {
//~ cout << "[";
//~ cout << affiche(v) <<"]";
//~ cout.flush();
//~ }
if (stepssave) {
save(svgfile+affiche(v));
}
/// 3 possible cases :
/// (1) not enought data (make a loop to the general state)
/// (2) there is no solution (add a new state and update X)
/// (3) there is a solution (make a return of transitions)
if (S[v] < seuil) // case (1) not enought data
{
// cout << "CASE (1)" << endl;
if (generalstate == -1)
{ // if the general state was not created, we create it
generalstate = addState (v, 0, 1 / float(Sigma.size () + 1));
for (b = Sigma.begin (); b != Sigma.end (); ++b)
{
MA::addTransition (generalstate, *b, generalstate, 1 / float(Sigma.size () + 1));
}
}
addTransition (w, a, generalstate, ((double) S[v] / (double) S[w]));
XR[w + a] = generalstate;
if (verbose)
{
cout << "S";
cout.flush ();
}
}
else
{
solution.clear (); // init solutions
// calculate the solution of the linear system
sol (modeVariables, solution, v, S, simplx, prec / pow(float(S[v]), float(0.4)), moderet, modeeps, W, maxmots, false);
if (solution.empty ()) // if there is no solution (case (2) add a new state and update X
{
// cout << "CASE (2)" << endl;
// if there is no solution then we add the state associated with v
// updating X and tau (val will contain tau[v])
val = 0;
for (b = Sigma.begin (); b != Sigma.end (); b++)
{ // pour toute les lettres de l'alphabet
v += *b;
//v.push_back (*b); // on ajoute b a la fin de v
if (S.find (v) != S.end ())
{ // si vb appartient a l'echantillon, alors
X.push_back (v); // on l'ajoute a X
val += S[v]; // et val = val + S(vb\Sigma^*)
}
z = v.end ();
--z;
v.erase (z); //v.pop_back (); // on efface la derniere lettre pour que la variable v = le mot v.
}
if (verbose)
{
cout << "A";
cout.flush ();
}
addState (v,0, 1 - (val / (double) S[v])); // adding the new state
if (size () > maxstates)
throw 1;
addTransition (w, a, v, ((double) S[v] / (double) S[w])); // updating phi : phi(w,a,wa) = S(wa)/S(w)
}
else
{
// cout << "CASE (3)" << endl;
// else we return transitions
if (verbose)
{
cout << "R";
cout.flush ();
}
for (q = Q.begin (); q != Q.end (); q++)
{
val = (float) solution[*q] *
((double) S[v] / (double) S[w]);
if (val != 0)
{
addTransition (w, a, *q, val);
}
}
}
}
}
if (verbose)
cout << endl;
erase_transitions (epsprime, -epsprime); // deleting transitions less than epsprime
//best_transition_delete(S,verbose);
if (modeVariables == nonconstrained) {
return VAL(0);
}
else {
return renormalise (); // renormalisation in order to disable borders effects
}
}
catch (int erreur) {
if (PFA_VERBOSE)
{
if (erreur != 1)
{
cerr << "PFA::DEES(Sample S)" << endl;
}
switch (erreur)
{
case 0:
cerr << "Sample vide !!!" << endl;
break;
case 1: // il y a trop d'etats
erase_transitions (epsprime);
return renormalise ();
break;
default:
cerr << "Erreur n∞" << erreur << endl;
}
}
return ERR (erreur);
}
}
