test_solverSoth.cpp
Go to the documentation of this file.
1 /*
2  * Copyright 2010,
3  * François Bleibel,
4  * Olivier Stasse,
5  *
6  * CNRS/AIST
7  *
8  */
9 
10 #define VP_DEBUG_MODE 45
11 #include <fstream>
12 #include <sot/core/debug.hh>
13 #include <sot/core/solver-hierarchical-inequalities.hh>
14 
15 #ifndef WIN32
16 #include <sys/time.h>
17 #else /*WIN32*/
18 #include <sot/core/utils-windows.hh>
19 #endif /*WIN32*/
20 // #define WITH_CHRONO
21 
22 using namespace dynamicgraph::sot;
23 
24 /* ---------------------------------------------------------- */
25 /* ---------------------------------------------------------- */
26 /* ---------------------------------------------------------- */
27 
28 void parseTest(const std::string filename) {
29  using namespace std;
30  std::ifstream off(filename.c_str());
31  std::string bs;
32 
33  bubMatrix Rh;
34  SolverHierarchicalInequalities::ConstraintList constraintH;
35  std::vector<bubMatrix> Jes;
36  std::vector<bubVector> ees;
37  std::vector<bubMatrix> Jis;
38  std::vector<bubVector> eiInfs;
39  std::vector<bubVector> eiSups;
40  std::vector<ConstraintMem::BoundSideVector> bounds;
41 
42  int nJ;
43  int me, mi;
44  bubMatrix Je, Ji;
45  bubVector ee, eiInf, eiSup;
46  ConstraintMem::BoundSideVector eiBoundSide;
47 
48  off >> bs;
49  if (bs != "variable") {
50  cerr << "!! '" << bs << "'" << endl;
51  return;
52  }
53  off >> bs;
54  if (bs != "size") {
55  cerr << "!! '" << bs << "'" << endl;
56  return;
57  }
58  off >> nJ;
59 
60  sotRotationComposedInExtenso Qh(nJ);
61  std::deque<SolverHierarchicalInequalities *> solvers;
62 
63  for (unsigned int level = 0;; ++level) {
64  /* --- Parse egalities --- */
65  off >> bs;
66  if (bs == "end") {
67  break;
68  } else if (bs != "level") {
69  cerr << "!! '" << bs << "'" << endl;
70  return;
71  }
72  off >> bs;
73  if (bs != "equalities") {
74  cerr << "!! '" << bs << "'" << endl;
75  return;
76  }
77  off >> me;
78  Je.resize(me, nJ);
79  ee.resize(me);
80  if (me > 0)
81  for (int i = 0; i < me; ++i) {
82  for (int j = 0; j < nJ; ++j) off >> Je(i, j);
83  off >> ee(i);
84  }
85 
86  /* --- Parse inequalities --- */
87  off >> bs;
88  if (bs != "inequalities") {
89  cerr << "!! '" << bs << "'" << endl;
90  return;
91  }
92  off >> mi;
93  Ji.resize(mi, nJ);
94  eiInf.resize(mi);
95  eiSup.resize(mi);
96  eiBoundSide.resize(mi);
97  if (mi > 0)
98  for (int i = 0; i < mi; ++i) {
99  for (int j = 0; j < nJ; ++j) off >> Ji(i, j);
100  std::string number;
101  eiBoundSide[i] = ConstraintMem::BOUND_VOID;
102  off >> number;
103  if (number != "X") {
104  eiBoundSide[i] = (ConstraintMem::BoundSideType)(
105  eiBoundSide[i] | ConstraintMem::BOUND_INF);
106  eiInf(i) = atof(number.c_str());
107  } else {
108  eiInf(i) = 1e-66;
109  }
110  off >> number;
111  if (number != "X") {
112  eiBoundSide[i] = (ConstraintMem::BoundSideType)(
113  eiBoundSide[i] | ConstraintMem::BOUND_SUP);
114  eiSup(i) = atof(number.c_str());
115  } else {
116  eiSup(i) = 1e-66;
117  }
118  }
119 
120  struct timeval t0, t1;
121  double dtsolver;
122  sotDEBUG(15)
123  << "/* ----------------------------------------------------- */"
124  << std::endl;
125  sotDEBUG(15)
126  << "/* ----------------------------------------------------- */"
127  << std::endl;
128  sotDEBUG(15)
129  << "/* ----------------------------------------------------- */"
130  << std::endl;
131  sotDEBUG(5) << "ee" << level << " = " << (MATLAB)ee << endl;
132  sotDEBUG(5) << "eiInf" << level << " = " << (MATLAB)eiInf << endl;
133  sotDEBUG(5) << "eiSup" << level << " = " << (MATLAB)eiSup << endl;
134  sotDEBUG(5) << "Je" << level << " = " << (MATLAB)Je << endl;
135  sotDEBUG(5) << "Ji" << level << " = " << (MATLAB)Ji << endl;
136  gettimeofday(&t0, NULL);
137 
138  Jes.push_back(Je);
139  Jis.push_back(Ji);
140  ees.push_back(ee);
141  eiInfs.push_back(eiInf);
142  eiSups.push_back(eiSup);
143  bounds.push_back(eiBoundSide);
144 
145  sotDEBUG(1) << "--- Level " << level << std::endl;
146  SolverHierarchicalInequalities *solver =
147  new SolverHierarchicalInequalities(nJ, Qh, Rh, constraintH);
148  solver->initConstraintSize(Je.size1() + Ji.size1());
149  if (solvers.size() == 0)
150  solver->setInitialConditionVoid();
151  else {
152  SolverHierarchicalInequalities *solverPrec = solvers.back();
153  solver->setInitialCondition(solverPrec->u0, solverPrec->rankh);
154  }
155  solver->recordInitialConditions();
156  solvers.push_back(solver);
157 
158  solver->solve(Je, ee, Ji, eiInf, eiSup, eiBoundSide);
159 
160  gettimeofday(&t1, NULL);
161  dtsolver = (t1.tv_sec - t0.tv_sec) * 1000. +
162  (t1.tv_usec - t0.tv_usec + 0.) / 1000.;
163  sotDEBUG(1) << "u" << level << " = " << (MATLAB)solver->u0 << endl;
164  cout << "dtSOLV_" << level << " = " << dtsolver << "%ms" << endl;
165 
166  solver->computeDifferentialCondition();
167 #ifdef VP_DEBUG
168  solver->printDifferentialCondition(sotDEBUGFLOW.outputbuffer);
169 #endif
170  }
171 
172  for (unsigned int repet = 0; repet < 1; ++repet) {
173  cout << "Repet = " << repet << std::endl;
174  struct timeval t0, t1;
175  double dtsolver;
176  constraintH.resize(0);
177  Rh *= 0;
178  Qh.clear();
179  for (unsigned int level = 0; level < solvers.size(); ++level) {
180  gettimeofday(&t0, NULL);
181  sotDEBUG(1) << "--- Level " << level << std::endl;
182  SolverHierarchicalInequalities *solver = solvers[level];
183  if (level == 0)
184  solver->setInitialConditionVoid();
185  else {
186  SolverHierarchicalInequalities *solverPrec = solvers[level - 1];
187  solver->setInitialCondition(solverPrec->u0, solverPrec->rankh);
188  }
189 
190  solver->recordInitialConditions();
191 #ifdef WITH_WARM_START
192  solver->warmStart();
193 #endif
194  gettimeofday(&t1, NULL);
195  dtsolver = (t1.tv_sec - t0.tv_sec) * 1000. +
196  (t1.tv_usec - t0.tv_usec + 0.) / 1000.;
197  sotDEBUG(1) << "dtWS_" << level << " = " << dtsolver << "%ms"
198  << endl;
199  cout << " " << dtsolver;
200  gettimeofday(&t0, NULL);
201 
202  solver->solve(Jes[level], ees[level], Jis[level], eiInfs[level],
203  eiSups[level], bounds[level], solver->getSlackActiveSet());
204  sotDEBUG(1) << "u" << level << " = " << (MATLAB)solver->u0 << endl;
205  gettimeofday(&t1, NULL);
206  dtsolver = (t1.tv_sec - t0.tv_sec) * 1000. +
207  (t1.tv_usec - t0.tv_usec + 0.) / 1000.;
208  cout << " " << dtsolver;
209  sotDEBUG(1) << "dtSOLV_" << level << " = " << dtsolver << "%ms"
210  << endl;
211  gettimeofday(&t0, NULL);
212 
213  solver->computeDifferentialCondition();
214 #ifdef VP_DEBUG
215  solver->printDifferentialCondition(sotDEBUGFLOW.outputbuffer);
216 #endif
217 
218  gettimeofday(&t1, NULL);
219  dtsolver = (t1.tv_sec - t0.tv_sec) * 1000. +
220  (t1.tv_usec - t0.tv_usec + 0.) / 1000.;
221  cout << " " << dtsolver;
222  sotDEBUG(1) << "dtREC_" << level << " = " << dtsolver << "%ms"
223  << endl;
224  }
225  std::cout << std::endl;
226  }
227 
228  for (unsigned int level = 0; level < solvers.size(); ++level) {
229  delete solvers[level];
230  solvers[level] = NULL;
231  }
232  solvers.clear();
233 }
234 
235 /* ---------------------------------------------------------- */
236 void deparse(std::vector<bubMatrix> Jes, std::vector<bubVector> ees,
237  std::vector<bubMatrix> Jis, std::vector<bubVector> eiInfs,
238  std::vector<bubVector> eiSups,
239  std::vector<ConstraintMem::BoundSideVector> bounds) {
240  using namespace std;
241  cout << "variable size " << Jes[0].size2() << endl;
242 
243  for (unsigned int i = 0; i < Jes.size(); ++i) {
244  bubMatrix &Je = Jes[i];
245  bubMatrix &Ji = Jis[i];
246  bubVector &ee = ees[i];
247  bubVector &eiInf = eiInfs[i];
248  bubVector &eiSup = eiSups[i];
249  ConstraintMem::BoundSideVector &boundSide = bounds[i];
250 
251  cout << endl
252  << endl
253  << "level" << endl
254  << endl
255  << "equalities " << ee.size() << endl;
256  if (ee.size() > 0)
257  for (unsigned int i = 0; i < ee.size(); ++i) {
258  for (unsigned int j = 0; j < Je.size2(); ++j) cout << Je(i, j) << " ";
259  cout << "\t" << ee(i) << endl;
260  }
261 
262  unsigned int nbIneq = 0;
263  for (unsigned int i = 0; i < boundSide.size(); ++i) {
264  if (boundSide[i] & ConstraintMem::BOUND_INF) nbIneq++;
265  if (boundSide[i] & ConstraintMem::BOUND_SUP) nbIneq++;
266  }
267 
268  cout << endl << "inequalities " << nbIneq << endl;
269  if (eiInf.size() > 0)
270  for (unsigned int i = 0; i < eiInf.size(); ++i) {
271  if (boundSide[i] & ConstraintMem::BOUND_INF) {
272  for (unsigned int j = 0; j < Ji.size2(); ++j)
273  cout << -Ji(i, j) << " ";
274  cout << "\t"
275  << " X " << -eiInf(i) << endl;
276  }
277  if (boundSide[i] & ConstraintMem::BOUND_SUP) {
278  for (unsigned int j = 0; j < Ji.size2(); ++j) cout << Ji(i, j) << " ";
279  cout << "\t"
280  << " X " << eiSup(i) << endl;
281  }
282  }
283  }
284  sotDEBUG(15) << endl << endl << "end" << endl;
285 }
286 
287 void convertDoubleToSingle(const std::string filename) {
288  using namespace std;
289  std::ifstream off(filename.c_str());
290  std::string bs;
291 
292  int nJ;
293  int me, mi;
294  bubMatrix Je, Ji;
295  bubVector ee, eiInf, eiSup;
296  ConstraintMem::BoundSideVector eiBoundSide;
297 
298  off >> bs;
299  if (bs != "variable") {
300  cerr << "!! '" << bs << "'" << endl;
301  return;
302  }
303  off >> bs;
304  if (bs != "size") {
305  cerr << "!! '" << bs << "'" << endl;
306  return;
307  }
308  off >> nJ;
309 
310  /* --- Set config file --- */
311  std::vector<bubMatrix> Jes;
312  std::vector<bubVector> ees;
313  std::vector<bubMatrix> Jis;
314  std::vector<bubVector> eiInfs;
315  std::vector<bubVector> eiSups;
316  std::vector<ConstraintMem::BoundSideVector> bounds;
317 
318  for (unsigned int level = 0;; ++level) {
319  off >> bs;
320  if (bs == "end") {
321  break;
322  } else if (bs != "level") {
323  cerr << "!! '" << bs << "'" << endl;
324  return;
325  }
326  off >> bs;
327  if (bs != "equalities") {
328  cerr << "!! '" << bs << "'" << endl;
329  return;
330  }
331  off >> me;
332  Je.resize(me, nJ);
333  ee.resize(me);
334  if (me > 0)
335  for (int i = 0; i < me; ++i) {
336  for (int j = 0; j < nJ; ++j) off >> Je(i, j);
337  off >> ee(i);
338  }
339 
340  off >> bs;
341  if (bs != "inequalities") {
342  cerr << "!! '" << bs << "'" << endl;
343  return;
344  }
345  off >> mi;
346  Ji.resize(mi, nJ);
347  eiInf.resize(mi);
348  eiSup.resize(mi);
349  eiBoundSide.resize(mi);
350  if (mi > 0)
351  for (int i = 0; i < mi; ++i) {
352  for (int j = 0; j < nJ; ++j) off >> Ji(i, j);
353  std::string number;
354  eiBoundSide[i] = ConstraintMem::BOUND_VOID;
355  off >> number; // std::cout << "toto '" << number << "'" << std::endl;
356  if (number != "X") {
357  eiBoundSide[i] = (ConstraintMem::BoundSideType)(
358  eiBoundSide[i] | ConstraintMem::BOUND_INF);
359  eiInf(i) = atof(number.c_str());
360  } else {
361  eiInf(i) = 1e-66;
362  }
363  off >> number;
364  if (number != "X") {
365  eiBoundSide[i] = (ConstraintMem::BoundSideType)(
366  eiBoundSide[i] | ConstraintMem::BOUND_SUP);
367  eiSup(i) = atof(number.c_str());
368  } else {
369  eiSup(i) = 1e-66;
370  }
371  }
372  // Ji*=-1; eiInf*=-1;
373 
374  Jes.push_back(Je);
375  ees.push_back(ee);
376  Jis.push_back(Ji);
377  eiInfs.push_back(eiInf);
378  eiSups.push_back(eiSup);
379  bounds.push_back(eiBoundSide);
380  }
381 
382  deparse(Jes, ees, Jis, eiInfs, eiSups, bounds);
383 }
384 
385 /* ---------------------------------------------------------- */
386 /* ---------------------------------------------------------- */
387 /* ---------------------------------------------------------- */
388 void randBound(ConstraintMem::BoundSideVector &M, const unsigned int row) {
389  M.resize(row);
390  for (unsigned int i = 0; i < row; ++i) {
391  double c = ((rand() + 0.0) / RAND_MAX * 2) - 1.;
392  if (c < 0)
393  M[i] = ConstraintMem::BOUND_INF;
394  else
395  M[i] = ConstraintMem::BOUND_SUP;
396  }
397 }
398 
399 void randTest(const unsigned int nJ, const bool enableSolve[]) {
400  bubVector eiInf0(nJ), ee0(1), eiSup0(nJ);
401  bubMatrix Ji0(nJ, nJ), Je0(1, nJ);
402  ConstraintMem::BoundSideVector bound0(nJ, ConstraintMem::BOUND_INF);
403  Ji0.assign(bub::identity_matrix<double>(nJ));
404  eiInf0.assign(bub::zero_vector<double>(nJ));
405  Je0.assign(bub::zero_matrix<double>(1, nJ));
406  // std::fill(ee0.data().begin(),ee0.data().end(),1);
407  ee0(0) = 0;
408  Je0(0, 0) = 1;
409 
410  bubVector ee1, eiInf1, eiSup1;
411  bubMatrix Je1, Ji1;
412  ConstraintMem::BoundSideVector bound1;
413  randVector(ee1, 3);
414  sotDEBUG(15) << "ee1 = " << (MATLAB)ee1 << std::endl;
415  randVector(eiInf1, 3);
416  sotDEBUG(15) << "eiInf1 = " << (MATLAB)eiInf1 << std::endl;
417  randVector(eiSup1, 3);
418  sotDEBUG(15) << "eiSup1 = " << (MATLAB)eiSup1 << std::endl;
419  randBound(bound1, 3);
420  randMatrix(Je1, 3,
421  nJ); // sotDEBUG(15) << "Je1 = " << (MATLAB)Je1 << std::endl;
422  randMatrix(Ji1, 3, nJ);
423  sotDEBUG(15) << "Ji1 = " << (MATLAB)Ji1 << std::endl;
424  bubMatrix xhi;
425  randMatrix(xhi, 1, 3);
426  xhi(0, 2) = 0;
427  bub::project(Je1, bub::range(2, 3), bub::range(0, nJ)) = bub::prod(xhi, Je1);
428  sotDEBUG(15) << "Je1 = " << (MATLAB)Je1 << std::endl;
429  // randMatrix(xhi,3,3);
430  // bub::noalias(Ji1) = bub::prod(xhi,Je1);
431  // sotDEBUG(15) << "Ji1 = " << (MATLAB)Ji1 << std::endl;
432 
433  bubVector ee2, eiInf2, eiSup2;
434  bubMatrix Je2, Ji2;
435  ConstraintMem::BoundSideVector bound2;
436  randVector(ee2, 3);
437  sotDEBUG(15) << "ee2 = " << (MATLAB)ee2 << std::endl;
438  randVector(eiInf2, 3);
439  sotDEBUG(15) << "eiInf2 = " << (MATLAB)eiInf2 << std::endl;
440  randVector(eiSup2, 3);
441  sotDEBUG(15) << "eiSup2 = " << (MATLAB)eiSup2 << std::endl;
442  randBound(bound1, 3);
443  randMatrix(Je2, 3, nJ);
444  sotDEBUG(15) << "Je2 = " << (MATLAB)Je2 << std::endl;
445  randMatrix(Ji2, 3, nJ);
446  sotDEBUG(15) << "Ji2 = " << (MATLAB)Ji2 << std::endl;
447 
448  bubVector ee3, eiInf3, eiSup3;
449  bubMatrix Je3, Ji3;
450  ConstraintMem::BoundSideVector bound3;
451  randVector(ee3, 3);
452  sotDEBUG(15) << "ee3 = " << (MATLAB)ee3 << std::endl;
453  randVector(eiInf3, 3);
454  sotDEBUG(15) << "eiInf3 = " << (MATLAB)eiInf3 << std::endl;
455  randVector(eiSup3, 3);
456  sotDEBUG(15) << "eiSup3 = " << (MATLAB)eiSup3 << std::endl;
457  randBound(bound1, 3);
458  randMatrix(Je3, 3, nJ);
459  sotDEBUG(15) << "Je3 = " << (MATLAB)Je3 << std::endl;
460  randMatrix(Ji3, 3, nJ);
461  sotDEBUG(15) << "Ji3 = " << (MATLAB)Ji3 << std::endl;
462 
463  bubVector ee4(nJ), eiInf4(1), eiSup4(1);
464  bubMatrix Je4(nJ, nJ), Ji4(1, nJ);
465  ConstraintMem::BoundSideVector bound4(1, ConstraintMem::BOUND_INF);
466  Je4.assign(bub::identity_matrix<double>(nJ));
467  ee4.assign(bub::zero_vector<double>(nJ));
468  Ji4.assign(bub::zero_matrix<double>(1, nJ));
469  eiInf4.assign(bub::zero_vector<double>(1));
470  eiSup4.assign(bub::zero_vector<double>(1));
471 
472  /* --- Set config file --- */
473  std::vector<bubMatrix> Jes;
474  std::vector<bubVector> ees;
475  std::vector<bubMatrix> Jis;
476  std::vector<bubVector> eiInfs;
477  std::vector<bubVector> eiSups;
478  std::vector<ConstraintMem::BoundSideVector> bounds;
479 
480  if (enableSolve[0]) {
481  Jes.push_back(Je0);
482  ees.push_back(ee0);
483  Jis.push_back(Ji0);
484  eiInfs.push_back(eiInf0);
485  eiSups.push_back(eiSup0);
486  bounds.push_back(bound0);
487  }
488 
489  if (enableSolve[1]) {
490  Jes.push_back(Je1);
491  ees.push_back(ee1);
492  Jis.push_back(Ji1);
493  eiInfs.push_back(eiInf1);
494  eiSups.push_back(eiSup1);
495  bounds.push_back(bound1);
496  }
497  if (enableSolve[2]) {
498  Jes.push_back(Je2);
499  ees.push_back(ee2);
500  Jis.push_back(Ji2);
501  eiInfs.push_back(eiInf2);
502  eiSups.push_back(eiSup2);
503  bounds.push_back(bound2);
504  }
505  if (enableSolve[3]) {
506  Jes.push_back(Je3);
507  ees.push_back(ee3);
508  Jis.push_back(Ji3);
509  eiInfs.push_back(eiInf3);
510  eiSups.push_back(eiSup3);
511  bounds.push_back(bound3);
512  }
513  if (enableSolve[4]) {
514  Jes.push_back(Je4);
515  ees.push_back(ee4);
516  Jis.push_back(Ji4);
517  eiInfs.push_back(eiInf4);
518  eiSups.push_back(eiSup4);
519  bounds.push_back(bound4);
520  }
521  deparse(Jes, ees, Jis, eiInfs, eiSups, bounds);
522 
523  sotRotationComposedInExtenso Qh(nJ);
524  bubMatrix Rh;
525  SolverHierarchicalInequalities::ConstraintList constraintH;
526  SolverHierarchicalInequalities solver(nJ, Qh, Rh, constraintH);
527  solver.initConstraintSize((40 + 6 + 6 + 6 + 40) + 2);
528 
529  /* ---------------------------------------------------------- */
530 
531  if (enableSolve[0]) solver.solve(Je0, ee0, Ji0, eiInf0, eiSup0, bound0);
532  sotDEBUG(15) << "/* ----------------------------------------------------- */"
533  << std::endl;
534  sotDEBUG(15) << "/* ----------------------------------------------------- */"
535  << std::endl;
536  sotDEBUG(15) << "/* ----------------------------------------------------- */"
537  << std::endl;
538  if (enableSolve[1]) solver.solve(Je1, ee1, Ji1, eiInf1, eiSup1, bound1);
539  sotDEBUG(15) << "/* ----------------------------------------------------- */"
540  << std::endl;
541  sotDEBUG(15) << "/* ----------------------------------------------------- */"
542  << std::endl;
543  sotDEBUG(15) << "/* ----------------------------------------------------- */"
544  << std::endl;
545  if (enableSolve[2]) solver.solve(Je2, ee2, Ji2, eiInf2, eiSup2, bound2);
546  sotDEBUG(15) << "/* ----------------------------------------------------- */"
547  << std::endl;
548  sotDEBUG(15) << "/* ----------------------------------------------------- */"
549  << std::endl;
550  sotDEBUG(15) << "/* ----------------------------------------------------- */"
551  << std::endl;
552  if (enableSolve[3]) solver.solve(Je3, ee3, Ji3, eiInf3, eiSup3, bound3);
553  sotDEBUG(15) << "/* ----------------------------------------------------- */"
554  << std::endl;
555  sotDEBUG(15) << "/* ----------------------------------------------------- */"
556  << std::endl;
557  sotDEBUG(15) << "/* ----------------------------------------------------- */"
558  << std::endl;
559  if (enableSolve[4]) solver.solve(Je4, ee4, Ji4, eiInf4, eiSup4, bound4);
560 
561  /* ---------------------------------------------------------- */
562 
563  return;
564 }
565 
566 /* ---------------------------------------------------------- */
567 /* ---------------------------------------------------------- */
568 /* ---------------------------------------------------------- */
569 int main(void) {
570  // convertDoubleToSingle("/home/nmansard/src/StackOfTasks/tests/tools/testFR.txt");
571  // exit(0);
572 
573 #ifndef VP_DEBUG
574 #ifndef WITH_CHRONO
575  for (int i = 0; i < 10; ++i)
576 #endif
577 #endif
578  parseTest("/home/nmansard/src/StackOfTasks/tests//t.txt");
579  // bool enable [5] ={ 1,1,0,0,0};
580  // randTest(9,enable );
581 }
i
int i
deparse
void deparse(std::vector< bubMatrix > Jes, std::vector< bubVector > ees, std::vector< bubMatrix > Jis, std::vector< bubVector > eiInfs, std::vector< bubVector > eiSups, std::vector< ConstraintMem::BoundSideVector > bounds)
Definition: test_solverSoth.cpp:236
dynamicgraph::DebugTrace::outputbuffer
std::ostream & outputbuffer
bounds
list bounds
main
int main(void)
Definition: test_solverSoth.cpp:569
convertDoubleToSingle
void convertDoubleToSingle(const std::string filename)
Definition: test_solverSoth.cpp:287
c
Vec3f c
rand
def rand(n)
randBound
void randBound(ConstraintMem::BoundSideVector &M, const unsigned int row)
Definition: test_solverSoth.cpp:388
parseTest
void parseTest(const std::string filename)
Definition: test_solverSoth.cpp:28
sotDEBUG
#define sotDEBUG(level)
Definition: debug.hh:165
randTest
void randTest(const unsigned int nJ, const bool enableSolve[])
Definition: test_solverSoth.cpp:399
dynamicgraph::sot::sotDEBUGFLOW
SOT_CORE_EXPORT DebugTrace sotDEBUGFLOW

sot-core
Author(s): Olivier Stasse, ostasse@laas.fr
autogenerated on Wed Jun 21 2023 02:51:26