sadmen
/
openpilot_comma
mirror of https://github.com/commaai/openpilot.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Standardize line endings in repo (#30112)

Browse Source 
use lf by default
pull/30116/head
Justin Newberry 2 years ago committed by GitHub
parent 1dd4ade197
commit 205cf12258
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 4459 additions and 4457 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      .gitattributes
  2. 268
      third_party/acados/include/qpOASES_e/Constants.h
  3. 124
      third_party/acados/include/qpOASES_e/ConstraintProduct.h
  4. 442
      third_party/acados/include/qpOASES_e/Indexlist.h
  5. 574
      third_party/acados/include/qpOASES_e/Matrices.h
  6. 306
      third_party/acados/include/qpOASES_e/Options.h
  7. 4738
      third_party/acados/include/qpOASES_e/QProblem.h
  8. 620
      third_party/acados/include/qpOASES_e/Types.h
  9. 158
      third_party/acados/include/qpOASES_e/UnitTesting.h
  10. 124
      third_party/catch2/include/catch2/catch_reporter_automake.hpp
  11. 360
      third_party/catch2/include/catch2/catch_reporter_sonarqube.hpp
  12. 508
      third_party/catch2/include/catch2/catch_reporter_tap.hpp
  13. 438
      third_party/catch2/include/catch2/catch_reporter_teamcity.hpp
  14. 254
      third_party/snpe/include/DlSystem/IOBufferDataTypeMap.hpp

2
.gitattributes vendored
Unescape View File

@ -1,3 +1,5 @@
* text=auto
*.dlc filter=lfs diff=lfs merge=lfs -text
*.onnx filter=lfs diff=lfs merge=lfs -text
selfdrive/car/tests/test_models_segs.txt filter=lfs diff=lfs merge=lfs -text

268
third_party/acados/include/qpOASES_e/Constants.h vendored
Unescape View File

@ -1,134 +1,134 @@
/*
* This file is part of qpOASES.
*
* qpOASES -- An Implementation of the Online Active Set Strategy.
* Copyright (C) 2007-2015 by Hans Joachim Ferreau, Andreas Potschka,
* Christian Kirches et al. All rights reserved.
*
* qpOASES is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* qpOASES is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with qpOASES; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
/**
* \file include/qpOASES_e/Constants.h
* \author Hans Joachim Ferreau, Andreas Potschka, Christian Kirches
* \version 3.1embedded
* \date 2007-2015
*
* Definition of all global constants.
*/
#ifndef QPOASES_CONSTANTS_H
#define QPOASES_CONSTANTS_H
#include <qpOASES_e/Types.h>
#ifdef __CODE_GENERATION__
#define CONVERTTOSTRINGAUX(x) #x
#define CONVERTTOSTRING(x) CONVERTTOSTRINGAUX(x)
#ifndef QPOASES_CUSTOM_INTERFACE
#include "acado_qpoases3_interface.h"
#else
#include CONVERTTOSTRING(QPOASES_CUSTOM_INTERFACE)
#endif
#endif
BEGIN_NAMESPACE_QPOASES
#ifndef __EXTERNAL_DIMENSIONS__
/*#define QPOASES_NVMAX 50
#define QPOASES_NCMAX 100*/
#define QPOASES_NVMAX 287
#define QPOASES_NCMAX 709
#endif /* __EXTERNAL_DIMENSIONS__ */
/** Maximum number of variables within a QP formulation.
* Note: this value has to be positive! */
#define NVMAX QPOASES_NVMAX
/** Maximum number of constraints within a QP formulation.
* Note: this value has to be positive! */
#define NCMAX QPOASES_NCMAX
#if ( QPOASES_NVMAX > QPOASES_NCMAX )
#define NVCMAX QPOASES_NVMAX
#else
#define NVCMAX QPOASES_NCMAX
#endif
#if ( QPOASES_NVMAX > QPOASES_NCMAX )
#define NVCMIN QPOASES_NCMAX
#else
#define NVCMIN QPOASES_NVMAX
#endif
/** Maximum number of QPs in a sequence solved by means of the OQP interface.
* Note: this value has to be positive! */
#define NQPMAX 1000
/** Numerical value of machine precision (min eps, s.t. 1+eps > 1).
* Note: this value has to be positive! */
#ifndef __CODE_GENERATION__
#ifdef __USE_SINGLE_PRECISION__
static const real_t QPOASES_EPS = 1.193e-07;
#else
static const real_t QPOASES_EPS = 2.221e-16;
#endif /* __USE_SINGLE_PRECISION__ */
#endif /* __CODE_GENERATION__ */
/** Numerical value of zero (for situations in which it would be
* unreasonable to compare with 0.0).
* Note: this value has to be positive! */
static const real_t QPOASES_ZERO = 1.0e-25;
/** Numerical value of infinity (e.g. for non-existing bounds).
* Note: this value has to be positive! */
static const real_t QPOASES_INFTY = 1.0e20;
/** Tolerance to used for isEqual, isZero etc.
* Note: this value has to be positive! */
static const real_t QPOASES_TOL = 1.0e-25;
/** Maximum number of characters within a string.
* Note: this value should be at least 41! */
#define QPOASES_MAX_STRING_LENGTH 160
END_NAMESPACE_QPOASES
#endif /* QPOASES_CONSTANTS_H */
/*
* end of file
*/
/*
* This file is part of qpOASES.
*
* qpOASES -- An Implementation of the Online Active Set Strategy.
* Copyright (C) 2007-2015 by Hans Joachim Ferreau, Andreas Potschka,
* Christian Kirches et al. All rights reserved.
*
* qpOASES is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* qpOASES is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with qpOASES; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
/**
* \file include/qpOASES_e/Constants.h
* \author Hans Joachim Ferreau, Andreas Potschka, Christian Kirches
* \version 3.1embedded
* \date 2007-2015
*
* Definition of all global constants.
*/
#ifndef QPOASES_CONSTANTS_H
#define QPOASES_CONSTANTS_H
#include <qpOASES_e/Types.h>
#ifdef __CODE_GENERATION__
#define CONVERTTOSTRINGAUX(x) #x
#define CONVERTTOSTRING(x) CONVERTTOSTRINGAUX(x)
#ifndef QPOASES_CUSTOM_INTERFACE
#include "acado_qpoases3_interface.h"
#else
#include CONVERTTOSTRING(QPOASES_CUSTOM_INTERFACE)
#endif
#endif
BEGIN_NAMESPACE_QPOASES
#ifndef __EXTERNAL_DIMENSIONS__
/*#define QPOASES_NVMAX 50
#define QPOASES_NCMAX 100*/
#define QPOASES_NVMAX 287
#define QPOASES_NCMAX 709
#endif /* __EXTERNAL_DIMENSIONS__ */
/** Maximum number of variables within a QP formulation.
* Note: this value has to be positive! */
#define NVMAX QPOASES_NVMAX
/** Maximum number of constraints within a QP formulation.
* Note: this value has to be positive! */
#define NCMAX QPOASES_NCMAX
#if ( QPOASES_NVMAX > QPOASES_NCMAX )
#define NVCMAX QPOASES_NVMAX
#else
#define NVCMAX QPOASES_NCMAX
#endif
#if ( QPOASES_NVMAX > QPOASES_NCMAX )
#define NVCMIN QPOASES_NCMAX
#else
#define NVCMIN QPOASES_NVMAX
#endif
/** Maximum number of QPs in a sequence solved by means of the OQP interface.
* Note: this value has to be positive! */
#define NQPMAX 1000
/** Numerical value of machine precision (min eps, s.t. 1+eps > 1).
* Note: this value has to be positive! */
#ifndef __CODE_GENERATION__
#ifdef __USE_SINGLE_PRECISION__
static const real_t QPOASES_EPS = 1.193e-07;
#else
static const real_t QPOASES_EPS = 2.221e-16;
#endif /* __USE_SINGLE_PRECISION__ */
#endif /* __CODE_GENERATION__ */
/** Numerical value of zero (for situations in which it would be
* unreasonable to compare with 0.0).
* Note: this value has to be positive! */
static const real_t QPOASES_ZERO = 1.0e-25;
/** Numerical value of infinity (e.g. for non-existing bounds).
* Note: this value has to be positive! */
static const real_t QPOASES_INFTY = 1.0e20;
/** Tolerance to used for isEqual, isZero etc.
* Note: this value has to be positive! */
static const real_t QPOASES_TOL = 1.0e-25;
/** Maximum number of characters within a string.
* Note: this value should be at least 41! */
#define QPOASES_MAX_STRING_LENGTH 160
END_NAMESPACE_QPOASES
#endif /* QPOASES_CONSTANTS_H */
/*
* end of file
*/

124
third_party/acados/include/qpOASES_e/ConstraintProduct.h vendored
Unescape View File

@ -1,62 +1,62 @@
/*
* This file is part of qpOASES.
*
* qpOASES -- An Implementation of the Online Active Set Strategy.
* Copyright (C) 2007-2015 by Hans Joachim Ferreau, Andreas Potschka,
* Christian Kirches et al. All rights reserved.
*
* qpOASES is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* qpOASES is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with qpOASES; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
/**
* \file include/qpOASES_e/ConstraintProduct.h
* \author Hans Joachim Ferreau, Andreas Potschka, Christian Kirches (thanks to D. Kwame Minde Kufoalor)
* \version 3.1embedded
* \date 2009-2015
*
* Declaration of the ConstraintProduct interface which allows to specify a
* user-defined function for evaluating the constraint product at the
* current iterate to speed-up QP solution in case of a specially structured
* constraint matrix.
*/
#ifndef QPOASES_CONSTRAINT_PRODUCT_H
#define QPOASES_CONSTRAINT_PRODUCT_H
BEGIN_NAMESPACE_QPOASES
/**
* \brief Interface for specifying user-defined evaluations of constraint products.
*
* An interface which allows to specify a user-defined function for evaluating the
* constraint product at the current iterate to speed-up QP solution in case
* of a specially structured constraint matrix.
*
* \author Hans Joachim Ferreau (thanks to Kwame Minde Kufoalor)
* \version 3.1embedded
* \date 2009-2015
*/
typedef int(*ConstraintProduct)( int, const real_t* const, real_t* const );
END_NAMESPACE_QPOASES
#endif /* QPOASES_CONSTRAINT_PRODUCT_H */
/*
* This file is part of qpOASES.
*
* qpOASES -- An Implementation of the Online Active Set Strategy.
* Copyright (C) 2007-2015 by Hans Joachim Ferreau, Andreas Potschka,
* Christian Kirches et al. All rights reserved.
*
* qpOASES is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* qpOASES is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with qpOASES; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
/**
* \file include/qpOASES_e/ConstraintProduct.h
* \author Hans Joachim Ferreau, Andreas Potschka, Christian Kirches (thanks to D. Kwame Minde Kufoalor)
* \version 3.1embedded
* \date 2009-2015
*
* Declaration of the ConstraintProduct interface which allows to specify a
* user-defined function for evaluating the constraint product at the
* current iterate to speed-up QP solution in case of a specially structured
* constraint matrix.
*/
#ifndef QPOASES_CONSTRAINT_PRODUCT_H
#define QPOASES_CONSTRAINT_PRODUCT_H
BEGIN_NAMESPACE_QPOASES
/**
* \brief Interface for specifying user-defined evaluations of constraint products.
*
* An interface which allows to specify a user-defined function for evaluating the
* constraint product at the current iterate to speed-up QP solution in case
* of a specially structured constraint matrix.
*
* \author Hans Joachim Ferreau (thanks to Kwame Minde Kufoalor)
* \version 3.1embedded
* \date 2009-2015
*/
typedef int(*ConstraintProduct)( int, const real_t* const, real_t* const );
END_NAMESPACE_QPOASES
#endif /* QPOASES_CONSTRAINT_PRODUCT_H */

442
third_party/acados/include/qpOASES_e/Indexlist.h vendored
Unescape View File

@ -1,221 +1,221 @@
/*
* This file is part of qpOASES.
*
* qpOASES -- An Implementation of the Online Active Set Strategy.
* Copyright (C) 2007-2015 by Hans Joachim Ferreau, Andreas Potschka,
* Christian Kirches et al. All rights reserved.
*
* qpOASES is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* qpOASES is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with qpOASES; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
/**
* \file include/qpOASES_e/Indexlist.h
* \author Hans Joachim Ferreau, Andreas Potschka, Christian Kirches
* \version 3.1embedded
* \date 2007-2015
*
* Declaration of the Indexlist class designed to manage index lists of
* constraints and bounds within a SubjectTo object.
*/
#ifndef QPOASES_INDEXLIST_H
#define QPOASES_INDEXLIST_H
#include <qpOASES_e/Utils.h>
BEGIN_NAMESPACE_QPOASES
/**
* \brief Stores and manages index lists.
*
* This class manages index lists of active/inactive bounds/constraints.
*
* \author Hans Joachim Ferreau
* \version 3.1embedded
* \date 2007-2015
*/
typedef struct
{
int *number; /**< Array to store numbers of constraints or bounds. */
int *iSort; /**< Index list to sort vector \a number */
int length; /**< Length of index list. */
int first; /**< Physical index of first element. */
int last; /**< Physical index of last element. */
int lastusedindex; /**< Physical index of last entry in index list. */
int physicallength; /**< Physical length of index list. */
} Indexlist;
int Indexlist_calculateMemorySize( int n);
char *Indexlist_assignMemory(int n, Indexlist **mem, void *raw_memory);
Indexlist *Indexlist_createMemory( int n );
/** Constructor which takes the desired physical length of the index list. */
void IndexlistCON( Indexlist* _THIS,
int n /**< Physical length of index list. */
);
/** Copies all members from given rhs object.
* \return SUCCESSFUL_RETURN */
void IndexlistCPY( Indexlist* FROM,
Indexlist* TO
);
/** Initialises index list of desired physical length.
* \return SUCCESSFUL_RETURN \n
RET_INVALID_ARGUMENTS */
returnValue Indexlist_init( Indexlist* _THIS,
int n /**< Physical length of index list. */
);
/** Creates an array of all numbers within the index set in correct order.
* \return SUCCESSFUL_RETURN \n
RET_INDEXLIST_CORRUPTED */
returnValue Indexlist_getNumberArray( Indexlist* _THIS,
int** const numberarray /**< Output: Array of numbers (NULL on error). */
);
/** Creates an array of all numbers within the index set in correct order.
* \return SUCCESSFUL_RETURN \n
RET_INDEXLIST_CORRUPTED */
returnValue Indexlist_getISortArray( Indexlist* _THIS,
int** const iSortArray /**< Output: iSort Array. */
);
/** Determines the index within the index list at which a given number is stored.
* \return >= 0: Index of given number. \n
-1: Number not found. */
int Indexlist_getIndex( Indexlist* _THIS,
int givennumber /**< Number whose index shall be determined. */
);
/** Returns the number stored at a given physical index.
* \return >= 0: Number stored at given physical index. \n
-RET_INDEXLIST_OUTOFBOUNDS */
static inline int Indexlist_getNumber( Indexlist* _THIS,
int physicalindex /**< Physical index of the number to be returned. */
);
/** Returns the current length of the index list.
* \return Current length of the index list. */
static inline int Indexlist_getLength( Indexlist* _THIS
);
/** Returns last number within the index list.
* \return Last number within the index list. */
static inline int Indexlist_getLastNumber( Indexlist* _THIS
);
/** Adds number to index list.
* \return SUCCESSFUL_RETURN \n
RET_INDEXLIST_MUST_BE_REORDERD \n
RET_INDEXLIST_EXCEEDS_MAX_LENGTH */
returnValue Indexlist_addNumber( Indexlist* _THIS,
int addnumber /**< Number to be added. */
);
/** Removes number from index list.
* \return SUCCESSFUL_RETURN */
returnValue Indexlist_removeNumber( Indexlist* _THIS,
int removenumber /**< Number to be removed. */
);
/** Swaps two numbers within index list.
* \return SUCCESSFUL_RETURN */
returnValue Indexlist_swapNumbers( Indexlist* _THIS,
int number1, /**< First number for swapping. */
int number2 /**< Second number for swapping. */
);
/** Determines if a given number is contained in the index set.
* \return BT_TRUE iff number is contain in the index set */
static inline BooleanType Indexlist_isMember( Indexlist* _THIS,
int _number /**< Number to be tested for membership. */
);
/** Find first index j between -1 and length in sorted list of indices
* iSort such that numbers[iSort[j]] <= i < numbers[iSort[j+1]]. Uses
* bisection.
* \return j. */
int Indexlist_findInsert( Indexlist* _THIS,
int i
);
/*
* g e t N u m b e r
*/
static inline int Indexlist_getNumber( Indexlist* _THIS, int physicalindex )
{
/* consistency check */
if ( ( physicalindex < 0 ) || ( physicalindex > _THIS->length ) )
return -RET_INDEXLIST_OUTOFBOUNDS;
return _THIS->number[physicalindex];
}
/*
* g e t L e n g t h
*/
static inline int Indexlist_getLength( Indexlist* _THIS )
{
return _THIS->length;
}
/*
* g e t L a s t N u m b e r
*/
static inline int Indexlist_getLastNumber( Indexlist* _THIS )
{
return _THIS->number[_THIS->length-1];
}
/*
* g e t L a s t N u m b e r
*/
static inline BooleanType Indexlist_isMember( Indexlist* _THIS, int _number )
{
if ( Indexlist_getIndex( _THIS,_number ) >= 0 )
return BT_TRUE;
else
return BT_FALSE;
}
END_NAMESPACE_QPOASES
#endif /* QPOASES_INDEXLIST_H */
/*
* end of file
*/
/*
* This file is part of qpOASES.
*
* qpOASES -- An Implementation of the Online Active Set Strategy.
* Copyright (C) 2007-2015 by Hans Joachim Ferreau, Andreas Potschka,
* Christian Kirches et al. All rights reserved.
*
* qpOASES is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* qpOASES is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with qpOASES; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
/**
* \file include/qpOASES_e/Indexlist.h
* \author Hans Joachim Ferreau, Andreas Potschka, Christian Kirches
* \version 3.1embedded
* \date 2007-2015
*
* Declaration of the Indexlist class designed to manage index lists of
* constraints and bounds within a SubjectTo object.
*/
#ifndef QPOASES_INDEXLIST_H
#define QPOASES_INDEXLIST_H
#include <qpOASES_e/Utils.h>
BEGIN_NAMESPACE_QPOASES
/**
* \brief Stores and manages index lists.
*
* This class manages index lists of active/inactive bounds/constraints.
*
* \author Hans Joachim Ferreau
* \version 3.1embedded
* \date 2007-2015
*/
typedef struct
{
int *number; /**< Array to store numbers of constraints or bounds. */
int *iSort; /**< Index list to sort vector \a number */
int length; /**< Length of index list. */
int first; /**< Physical index of first element. */
int last; /**< Physical index of last element. */
int lastusedindex; /**< Physical index of last entry in index list. */
int physicallength; /**< Physical length of index list. */
} Indexlist;
int Indexlist_calculateMemorySize( int n);
char *Indexlist_assignMemory(int n, Indexlist **mem, void *raw_memory);
Indexlist *Indexlist_createMemory( int n );
/** Constructor which takes the desired physical length of the index list. */
void IndexlistCON( Indexlist* _THIS,
int n /**< Physical length of index list. */
);
/** Copies all members from given rhs object.
* \return SUCCESSFUL_RETURN */
void IndexlistCPY( Indexlist* FROM,
Indexlist* TO
);
/** Initialises index list of desired physical length.
* \return SUCCESSFUL_RETURN \n
RET_INVALID_ARGUMENTS */
returnValue Indexlist_init( Indexlist* _THIS,
int n /**< Physical length of index list. */
);
/** Creates an array of all numbers within the index set in correct order.
* \return SUCCESSFUL_RETURN \n
RET_INDEXLIST_CORRUPTED */
returnValue Indexlist_getNumberArray( Indexlist* _THIS,
int** const numberarray /**< Output: Array of numbers (NULL on error). */
);
/** Creates an array of all numbers within the index set in correct order.
* \return SUCCESSFUL_RETURN \n
RET_INDEXLIST_CORRUPTED */
returnValue Indexlist_getISortArray( Indexlist* _THIS,
int** const iSortArray /**< Output: iSort Array. */
);
/** Determines the index within the index list at which a given number is stored.
* \return >= 0: Index of given number. \n
-1: Number not found. */
int Indexlist_getIndex( Indexlist* _THIS,
int givennumber /**< Number whose index shall be determined. */
);
/** Returns the number stored at a given physical index.
* \return >= 0: Number stored at given physical index. \n
-RET_INDEXLIST_OUTOFBOUNDS */
static inline int Indexlist_getNumber( Indexlist* _THIS,
int physicalindex /**< Physical index of the number to be returned. */
);
/** Returns the current length of the index list.
* \return Current length of the index list. */
static inline int Indexlist_getLength( Indexlist* _THIS
);
/** Returns last number within the index list.
* \return Last number within the index list. */
static inline int Indexlist_getLastNumber( Indexlist* _THIS
);
/** Adds number to index list.
* \return SUCCESSFUL_RETURN \n
RET_INDEXLIST_MUST_BE_REORDERD \n
RET_INDEXLIST_EXCEEDS_MAX_LENGTH */
returnValue Indexlist_addNumber( Indexlist* _THIS,
int addnumber /**< Number to be added. */
);
/** Removes number from index list.
* \return SUCCESSFUL_RETURN */
returnValue Indexlist_removeNumber( Indexlist* _THIS,
int removenumber /**< Number to be removed. */
);
/** Swaps two numbers within index list.
* \return SUCCESSFUL_RETURN */
returnValue Indexlist_swapNumbers( Indexlist* _THIS,
int number1, /**< First number for swapping. */
int number2 /**< Second number for swapping. */
);
/** Determines if a given number is contained in the index set.
* \return BT_TRUE iff number is contain in the index set */
static inline BooleanType Indexlist_isMember( Indexlist* _THIS,
int _number /**< Number to be tested for membership. */
);
/** Find first index j between -1 and length in sorted list of indices
* iSort such that numbers[iSort[j]] <= i < numbers[iSort[j+1]]. Uses
* bisection.
* \return j. */
int Indexlist_findInsert( Indexlist* _THIS,
int i
);
/*
* g e t N u m b e r
*/
static inline int Indexlist_getNumber( Indexlist* _THIS, int physicalindex )
{
/* consistency check */
if ( ( physicalindex < 0 ) || ( physicalindex > _THIS->length ) )
return -RET_INDEXLIST_OUTOFBOUNDS;
return _THIS->number[physicalindex];
}
/*
* g e t L e n g t h
*/
static inline int Indexlist_getLength( Indexlist* _THIS )
{
return _THIS->length;
}
/*
* g e t L a s t N u m b e r
*/
static inline int Indexlist_getLastNumber( Indexlist* _THIS )
{
return _THIS->number[_THIS->length-1];
}
/*
* g e t L a s t N u m b e r
*/
static inline BooleanType Indexlist_isMember( Indexlist* _THIS, int _number )
{
if ( Indexlist_getIndex( _THIS,_number ) >= 0 )
return BT_TRUE;
else
return BT_FALSE;
}
END_NAMESPACE_QPOASES
#endif /* QPOASES_INDEXLIST_H */
/*
* end of file
*/

574
third_party/acados/include/qpOASES_e/Matrices.h vendored
Unescape View File

@ -1,287 +1,287 @@
/*
* This file is part of qpOASES.
*
* qpOASES -- An Implementation of the Online Active Set Strategy.
* Copyright (C) 2007-2015 by Hans Joachim Ferreau, Andreas Potschka,
* Christian Kirches et al. All rights reserved.
*
* qpOASES is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* qpOASES is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with qpOASES; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
/**
* \file include/qpOASES_e/Matrices.h
* \author Hans Joachim Ferreau, Andreas Potschka, Christian Kirches
* \version 3.1embedded
* \date 2009-2015
*
* Various matrix classes: Abstract base matrix class, dense and sparse matrices,
* including symmetry exploiting specializations.
*/
#ifndef QPOASES_MATRICES_H
#define QPOASES_MATRICES_H
#ifdef __USE_SINGLE_PRECISION__
// single precision
#define GEMM sgemm_
#define GEMV sgemv_
// #define SYR ssyr_
// #define SYR2 ssyr2_
#define POTRF spotrf_
#else
// double precision
#define GEMM dgemm_
#define GEMV dgemv_
// #define SYR dsyr_
// #define SYR2 dsyr2_
#define POTRF dpotrf_
#endif /* __USE_SINGLE_PRECISION__ */
#ifdef EXTERNAL_BLAS
// double precision
void dgemm_(char *ta, char *tb, int *m, int *n, int *k, double *alpha, double *A, int *lda, double *B, int ldb, double *beta, double *C, int *ldc);
void dgemv_(char *ta, int *m, int *n, double *alpha, double *A, int *lda, double *x, int *incx, double *beta, double *y, int *incy);
void dpotrf_(char *uplo, int *m, double *A, int *lda, int *info);
// single precision
void sgemm_(char *ta, char *tb, int *m, int *n, int *k, float *alpha, float *A, int *lda, float *B, int ldb, float *beta, float *C, int *ldc);
void sgemv_(char *ta, int *m, int *n, float *alpha, float *A, int *lda, float *x, int *incx, float *beta, float *y, int *incy);
void spotrf_(char *uplo, int *m, float *A, int *lda, int *info);
#else
/** Performs one of the matrix-matrix operation in double precision. */
void dgemm_ ( const char*, const char*, const unsigned long*, const unsigned long*, const unsigned long*,
const double*, const double*, const unsigned long*, const double*, const unsigned long*,
const double*, double*, const unsigned long* );
/** Performs one of the matrix-matrix operation in single precision. */
void sgemm_ ( const char*, const char*, const unsigned long*, const unsigned long*, const unsigned long*,
const float*, const float*, const unsigned long*, const float*, const unsigned long*,
const float*, float*, const unsigned long* );
/** Calculates the Cholesky factorization of a real symmetric positive definite matrix in double precision. */
void dpotrf_ ( const char *, const unsigned long *, double *, const unsigned long *, long * );
/** Calculates the Cholesky factorization of a real symmetric positive definite matrix in single precision. */
void spotrf_ ( const char *, const unsigned long *, float *, const unsigned long *, long * );
#endif
/** Performs a symmetric rank 1 operation in double precision. */
// void dsyr_ ( const char *, const unsigned long *, const double *, const double *,
// const unsigned long *, double *, const unsigned long *);
/** Performs a symmetric rank 1 operation in single precision. */
// void ssyr_ ( const char *, const unsigned long *, const float *, const float *,
// const unsigned long *, float *, const unsigned long *);
/** Performs a symmetric rank 2 operation in double precision. */
// void dsyr2_ ( const char *, const unsigned long *, const double *, const double *,
// const unsigned long *, const double *, const unsigned long *, double *, const unsigned long *);
/** Performs a symmetric rank 2 operation in single precision. */
// void ssyr2_ ( const char *, const unsigned long *, const float *, const float *,
// const unsigned long *, const float *, const unsigned long *, float *, const unsigned long *);
#include <qpOASES_e/Indexlist.h>
BEGIN_NAMESPACE_QPOASES
/**
* \brief Interfaces matrix-vector operations tailored to general dense matrices.
*
* Dense matrix class (row major format).
*
* \author Andreas Potschka, Christian Kirches, Hans Joachim Ferreau
* \version 3.1embedded
* \date 2011-2015
*/
typedef struct
{
real_t *val; /**< Vector of entries. */
int nRows; /**< Number of rows. */
int nCols; /**< Number of columns. */
int leaDim; /**< Leading dimension. */
} DenseMatrix;
int DenseMatrix_calculateMemorySize( int m, int n );
char *DenseMatrix_assignMemory( int m, int n, DenseMatrix **mem, void *raw_memory );
DenseMatrix *DenseMatrix_createMemory( int m, int n );
/** Constructor from vector of values.
* Caution: Data pointer must be valid throughout lifetime
*/
void DenseMatrixCON( DenseMatrix* _THIS,
int m, /**< Number of rows. */
int n, /**< Number of columns. */
int lD, /**< Leading dimension. */
real_t *v /**< Values. */
);
void DenseMatrixCPY( DenseMatrix* FROM,
DenseMatrix* TO
);
/** Frees all internal memory. */
void DenseMatrix_free( DenseMatrix* _THIS );
/** Constructor from vector of values.
* Caution: Data pointer must be valid throughout lifetime
*/
returnValue DenseMatrix_init( DenseMatrix* _THIS,
int m, /**< Number of rows. */
int n, /**< Number of columns. */
int lD, /**< Leading dimension. */
real_t *v /**< Values. */
);
/** Returns i-th diagonal entry.
* \return i-th diagonal entry */
real_t DenseMatrix_diag( DenseMatrix* _THIS,
int i /**< Index. */
);
/** Checks whether matrix is square and diagonal.
* \return BT_TRUE iff matrix is square and diagonal; \n
* BT_FALSE otherwise. */
BooleanType DenseMatrix_isDiag( DenseMatrix* _THIS );
/** Get the N-norm of the matrix
* \return N-norm of the matrix
*/
real_t DenseMatrix_getNorm( DenseMatrix* _THIS,
int type /**< Norm type, 1: one-norm, 2: Euclidean norm. */
);
/** Get the N-norm of a row
* \return N-norm of row \a rNum
*/
real_t DenseMatrix_getRowNorm( DenseMatrix* _THIS,
int rNum, /**< Row number. */
int type /**< Norm type, 1: one-norm, 2: Euclidean norm. */
);
/** Retrieve indexed entries of matrix row multiplied by alpha.
* \return SUCCESSFUL_RETURN */
returnValue DenseMatrix_getRow( DenseMatrix* _THIS,
int rNum, /**< Row number. */
const Indexlist* const icols, /**< Index list specifying columns. */
real_t alpha, /**< Scalar factor. */
real_t *row /**< Output row vector. */
);
/** Retrieve indexed entries of matrix column multiplied by alpha.
* \return SUCCESSFUL_RETURN */
returnValue DenseMatrix_getCol( DenseMatrix* _THIS,
int cNum, /**< Column number. */
const Indexlist* const irows, /**< Index list specifying rows. */
real_t alpha, /**< Scalar factor. */
real_t *col /**< Output column vector. */
);
/** Evaluate Y=alpha*A*X + beta*Y.
* \return SUCCESSFUL_RETURN. */
returnValue DenseMatrix_times( DenseMatrix* _THIS,
int xN, /**< Number of vectors to multiply. */
real_t alpha, /**< Scalar factor for matrix vector product. */
const real_t *x, /**< Input vector to be multiplied. */
int xLD, /**< Leading dimension of input x. */
real_t beta, /**< Scalar factor for y. */
real_t *y, /**< Output vector of results. */
int yLD /**< Leading dimension of output y. */
);
/** Evaluate Y=alpha*A'*X + beta*Y.
* \return SUCCESSFUL_RETURN. */
returnValue DenseMatrix_transTimes( DenseMatrix* _THIS,
int xN, /**< Number of vectors to multiply. */
real_t alpha, /**< Scalar factor for matrix vector product. */
const real_t *x, /**< Input vector to be multiplied. */
int xLD, /**< Leading dimension of input x. */
real_t beta, /**< Scalar factor for y. */
real_t *y, /**< Output vector of results. */
int yLD /**< Leading dimension of output y. */
);
/** Evaluate matrix vector product with submatrix given by Indexlist.
* \return SUCCESSFUL_RETURN */
returnValue DenseMatrix_subTimes( DenseMatrix* _THIS,
const Indexlist* const irows, /**< Index list specifying rows. */
const Indexlist* const icols, /**< Index list specifying columns. */
int xN, /**< Number of vectors to multiply. */
real_t alpha, /**< Scalar factor for matrix vector product. */
const real_t *x, /**< Input vector to be multiplied. */
int xLD, /**< Leading dimension of input x. */
real_t beta, /**< Scalar factor for y. */
real_t *y, /**< Output vector of results. */
int yLD, /**< Leading dimension of output y. */
BooleanType yCompr /**< Compressed storage for y. */
);
/** Evaluate matrix transpose vector product.
* \return SUCCESSFUL_RETURN */
returnValue DenseMatrix_subTransTimes( DenseMatrix* _THIS,
const Indexlist* const irows, /**< Index list specifying rows. */
const Indexlist* const icols, /**< Index list specifying columns. */
int xN, /**< Number of vectors to multiply. */
real_t alpha, /**< Scalar factor for matrix vector product. */
const real_t *x, /**< Input vector to be multiplied. */
int xLD, /**< Leading dimension of input x. */
real_t beta, /**< Scalar factor for y. */
real_t *y, /**< Output vector of results. */
int yLD /**< Leading dimension of output y. */
);
/** Adds given offset to diagonal of matrix.
* \return SUCCESSFUL_RETURN \n
RET_NO_DIAGONAL_AVAILABLE */
returnValue DenseMatrix_addToDiag( DenseMatrix* _THIS,
real_t alpha /**< Diagonal offset. */
);
/** Prints matrix to screen.
* \return SUCCESSFUL_RETURN */
returnValue DenseMatrix_print( DenseMatrix* _THIS
);
static inline real_t* DenseMatrix_getVal( DenseMatrix* _THIS ) { return _THIS->val; }
/** Compute bilinear form y = x'*H*x using submatrix given by index list.
* \return SUCCESSFUL_RETURN */
returnValue DenseMatrix_bilinear( DenseMatrix* _THIS,
const Indexlist* const icols, /**< Index list specifying columns of x. */
int xN, /**< Number of vectors to multiply. */
const real_t *x, /**< Input vector to be multiplied (uncompressed). */
int xLD, /**< Leading dimension of input x. */
real_t *y, /**< Output vector of results (compressed). */
int yLD /**< Leading dimension of output y. */
);
END_NAMESPACE_QPOASES
#endif /* QPOASES_MATRICES_H */
/*
* This file is part of qpOASES.
*
* qpOASES -- An Implementation of the Online Active Set Strategy.
* Copyright (C) 2007-2015 by Hans Joachim Ferreau, Andreas Potschka,
* Christian Kirches et al. All rights reserved.
*
* qpOASES is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* qpOASES is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with qpOASES; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
/**
* \file include/qpOASES_e/Matrices.h
* \author Hans Joachim Ferreau, Andreas Potschka, Christian Kirches
* \version 3.1embedded
* \date 2009-2015
*
* Various matrix classes: Abstract base matrix class, dense and sparse matrices,
* including symmetry exploiting specializations.
*/
#ifndef QPOASES_MATRICES_H
#define QPOASES_MATRICES_H
#ifdef __USE_SINGLE_PRECISION__
// single precision
#define GEMM sgemm_
#define GEMV sgemv_
// #define SYR ssyr_
// #define SYR2 ssyr2_
#define POTRF spotrf_
#else
// double precision
#define GEMM dgemm_
#define GEMV dgemv_
// #define SYR dsyr_
// #define SYR2 dsyr2_
#define POTRF dpotrf_
#endif /* __USE_SINGLE_PRECISION__ */
#ifdef EXTERNAL_BLAS
// double precision
void dgemm_(char *ta, char *tb, int *m, int *n, int *k, double *alpha, double *A, int *lda, double *B, int ldb, double *beta, double *C, int *ldc);
void dgemv_(char *ta, int *m, int *n, double *alpha, double *A, int *lda, double *x, int *incx, double *beta, double *y, int *incy);
void dpotrf_(char *uplo, int *m, double *A, int *lda, int *info);
// single precision
void sgemm_(char *ta, char *tb, int *m, int *n, int *k, float *alpha, float *A, int *lda, float *B, int ldb, float *beta, float *C, int *ldc);
void sgemv_(char *ta, int *m, int *n, float *alpha, float *A, int *lda, float *x, int *incx, float *beta, float *y, int *incy);
void spotrf_(char *uplo, int *m, float *A, int *lda, int *info);
#else
/** Performs one of the matrix-matrix operation in double precision. */
void dgemm_ ( const char*, const char*, const unsigned long*, const unsigned long*, const unsigned long*,
const double*, const double*, const unsigned long*, const double*, const unsigned long*,
const double*, double*, const unsigned long* );
/** Performs one of the matrix-matrix operation in single precision. */
void sgemm_ ( const char*, const char*, const unsigned long*, const unsigned long*, const unsigned long*,
const float*, const float*, const unsigned long*, const float*, const unsigned long*,
const float*, float*, const unsigned long* );
/** Calculates the Cholesky factorization of a real symmetric positive definite matrix in double precision. */
void dpotrf_ ( const char *, const unsigned long *, double *, const unsigned long *, long * );
/** Calculates the Cholesky factorization of a real symmetric positive definite matrix in single precision. */
void spotrf_ ( const char *, const unsigned long *, float *, const unsigned long *, long * );
#endif
/** Performs a symmetric rank 1 operation in double precision. */
// void dsyr_ ( const char *, const unsigned long *, const double *, const double *,
// const unsigned long *, double *, const unsigned long *);
/** Performs a symmetric rank 1 operation in single precision. */
// void ssyr_ ( const char *, const unsigned long *, const float *, const float *,
// const unsigned long *, float *, const unsigned long *);
/** Performs a symmetric rank 2 operation in double precision. */
// void dsyr2_ ( const char *, const unsigned long *, const double *, const double *,
// const unsigned long *, const double *, const unsigned long *, double *, const unsigned long *);
/** Performs a symmetric rank 2 operation in single precision. */
// void ssyr2_ ( const char *, const unsigned long *, const float *, const float *,
// const unsigned long *, const float *, const unsigned long *, float *, const unsigned long *);
#include <qpOASES_e/Indexlist.h>
BEGIN_NAMESPACE_QPOASES
/**
* \brief Interfaces matrix-vector operations tailored to general dense matrices.
*
* Dense matrix class (row major format).
*
* \author Andreas Potschka, Christian Kirches, Hans Joachim Ferreau
* \version 3.1embedded
* \date 2011-2015
*/
typedef struct
{
real_t *val; /**< Vector of entries. */
int nRows; /**< Number of rows. */
int nCols; /**< Number of columns. */
int leaDim; /**< Leading dimension. */
} DenseMatrix;
int DenseMatrix_calculateMemorySize( int m, int n );
char *DenseMatrix_assignMemory( int m, int n, DenseMatrix **mem, void *raw_memory );
DenseMatrix *DenseMatrix_createMemory( int m, int n );
/** Constructor from vector of values.
* Caution: Data pointer must be valid throughout lifetime
*/
void DenseMatrixCON( DenseMatrix* _THIS,
int m, /**< Number of rows. */
int n, /**< Number of columns. */
int lD, /**< Leading dimension. */
real_t *v /**< Values. */
);
void DenseMatrixCPY( DenseMatrix* FROM,
DenseMatrix* TO
);
/** Frees all internal memory. */
void DenseMatrix_free( DenseMatrix* _THIS );
/** Constructor from vector of values.
* Caution: Data pointer must be valid throughout lifetime
*/
returnValue DenseMatrix_init( DenseMatrix* _THIS,
int m, /**< Number of rows. */
int n, /**< Number of columns. */
int lD, /**< Leading dimension. */
real_t *v /**< Values. */
);
/** Returns i-th diagonal entry.
* \return i-th diagonal entry */
real_t DenseMatrix_diag( DenseMatrix* _THIS,
int i /**< Index. */
);
/** Checks whether matrix is square and diagonal.
* \return BT_TRUE iff matrix is square and diagonal; \n
* BT_FALSE otherwise. */
BooleanType DenseMatrix_isDiag( DenseMatrix* _THIS );
/** Get the N-norm of the matrix
* \return N-norm of the matrix
*/
real_t DenseMatrix_getNorm( DenseMatrix* _THIS,
int type /**< Norm type, 1: one-norm, 2: Euclidean norm. */
);
/** Get the N-norm of a row
* \return N-norm of row \a rNum
*/
real_t DenseMatrix_getRowNorm( DenseMatrix* _THIS,
int rNum, /**< Row number. */
int type /**< Norm type, 1: one-norm, 2: Euclidean norm. */
);
/** Retrieve indexed entries of matrix row multiplied by alpha.
* \return SUCCESSFUL_RETURN */
returnValue DenseMatrix_getRow( DenseMatrix* _THIS,
int rNum, /**< Row number. */
const Indexlist* const icols, /**< Index list specifying columns. */
real_t alpha, /**< Scalar factor. */
real_t *row /**< Output row vector. */
);
/** Retrieve indexed entries of matrix column multiplied by alpha.
* \return SUCCESSFUL_RETURN */
returnValue DenseMatrix_getCol( DenseMatrix* _THIS,
int cNum, /**< Column number. */
const Indexlist* const irows, /**< Index list specifying rows. */
real_t alpha, /**< Scalar factor. */
real_t *col /**< Output column vector. */
);
/** Evaluate Y=alpha*A*X + beta*Y.
* \return SUCCESSFUL_RETURN. */
returnValue DenseMatrix_times( DenseMatrix* _THIS,
int xN, /**< Number of vectors to multiply. */
real_t alpha, /**< Scalar factor for matrix vector product. */
const real_t *x, /**< Input vector to be multiplied. */
int xLD, /**< Leading dimension of input x. */
real_t beta, /**< Scalar factor for y. */
real_t *y, /**< Output vector of results. */
int yLD /**< Leading dimension of output y. */
);
/** Evaluate Y=alpha*A'*X + beta*Y.
* \return SUCCESSFUL_RETURN. */
returnValue DenseMatrix_transTimes( DenseMatrix* _THIS,
int xN, /**< Number of vectors to multiply. */
real_t alpha, /**< Scalar factor for matrix vector product. */
const real_t *x, /**< Input vector to be multiplied. */
int xLD, /**< Leading dimension of input x. */
real_t beta, /**< Scalar factor for y. */
real_t *y, /**< Output vector of results. */
int yLD /**< Leading dimension of output y. */
);
/** Evaluate matrix vector product with submatrix given by Indexlist.
* \return SUCCESSFUL_RETURN */
returnValue DenseMatrix_subTimes( DenseMatrix* _THIS,
const Indexlist* const irows, /**< Index list specifying rows. */
const Indexlist* const icols, /**< Index list specifying columns. */
int xN, /**< Number of vectors to multiply. */
real_t alpha, /**< Scalar factor for matrix vector product. */
const real_t *x, /**< Input vector to be multiplied. */
int xLD, /**< Leading dimension of input x. */
real_t beta, /**< Scalar factor for y. */
real_t *y, /**< Output vector of results. */
int yLD, /**< Leading dimension of output y. */
BooleanType yCompr /**< Compressed storage for y. */
);
/** Evaluate matrix transpose vector product.
* \return SUCCESSFUL_RETURN */
returnValue DenseMatrix_subTransTimes( DenseMatrix* _THIS,
const Indexlist* const irows, /**< Index list specifying rows. */
const Indexlist* const icols, /**< Index list specifying columns. */
int xN, /**< Number of vectors to multiply. */
real_t alpha, /**< Scalar factor for matrix vector product. */
const real_t *x, /**< Input vector to be multiplied. */
int xLD, /**< Leading dimension of input x. */
real_t beta, /**< Scalar factor for y. */
real_t *y, /**< Output vector of results. */
int yLD /**< Leading dimension of output y. */
);
/** Adds given offset to diagonal of matrix.
* \return SUCCESSFUL_RETURN \n
RET_NO_DIAGONAL_AVAILABLE */
returnValue DenseMatrix_addToDiag( DenseMatrix* _THIS,
real_t alpha /**< Diagonal offset. */
);
/** Prints matrix to screen.
* \return SUCCESSFUL_RETURN */
returnValue DenseMatrix_print( DenseMatrix* _THIS
);
static inline real_t* DenseMatrix_getVal( DenseMatrix* _THIS ) { return _THIS->val; }
/** Compute bilinear form y = x'*H*x using submatrix given by index list.
* \return SUCCESSFUL_RETURN */
returnValue DenseMatrix_bilinear( DenseMatrix* _THIS,
const Indexlist* const icols, /**< Index list specifying columns of x. */
int xN, /**< Number of vectors to multiply. */
const real_t *x, /**< Input vector to be multiplied (uncompressed). */
int xLD, /**< Leading dimension of input x. */
real_t *y, /**< Output vector of results (compressed). */
int yLD /**< Leading dimension of output y. */
);
END_NAMESPACE_QPOASES
#endif /* QPOASES_MATRICES_H */

306
third_party/acados/include/qpOASES_e/Options.h vendored
Unescape View File

@ -1,153 +1,153 @@
/*
* This file is part of qpOASES.
*
* qpOASES -- An Implementation of the Online Active Set Strategy.
* Copyright (C) 2007-2015 by Hans Joachim Ferreau, Andreas Potschka,
* Christian Kirches et al. All rights reserved.
*
* qpOASES is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* qpOASES is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with qpOASES; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
/**
* \file include/qpOASES_e/Options.h
* \author Hans Joachim Ferreau, Andreas Potschka, Christian Kirches
* \version 3.1embedded
* \date 2007-2015
*
* Declaration of the Options class designed to manage user-specified
* options for solving a QProblem.
*/
#ifndef QPOASES_OPTIONS_H
#define QPOASES_OPTIONS_H
#include <qpOASES_e/Utils.h>
BEGIN_NAMESPACE_QPOASES
/**
* \brief Manages all user-specified options for solving QPs.
*
* This class manages all user-specified options used for solving
* quadratic programs.
*
* \author Hans Joachim Ferreau, Andreas Potschka, Christian Kirches
* \version 3.1embedded
* \date 2007-2015
*/
typedef struct
{
PrintLevel printLevel; /**< Print level. */
BooleanType enableRamping; /**< Specifies whether ramping shall be enabled or not. */
BooleanType enableFarBounds; /**< Specifies whether far bounds shall be used or not. */
BooleanType enableFlippingBounds; /**< Specifies whether flipping bounds shall be used or not. */
BooleanType enableRegularisation; /**< Specifies whether Hessian matrix shall be regularised in case semi-definiteness is detected. */
BooleanType enableFullLITests; /**< Specifies whether condition-hardened LI test shall be used or not. */
BooleanType enableNZCTests; /**< Specifies whether nonzero curvature tests shall be used. */
int enableDriftCorrection; /**< Specifies the frequency of drift corrections (0 = off). */
int enableCholeskyRefactorisation; /**< Specifies the frequency of full refactorisation of proj. Hessian (otherwise updates). */
BooleanType enableEqualities; /**< Specifies whether equalities shall be always treated as active constraints. */
real_t terminationTolerance; /**< Termination tolerance. */
real_t boundTolerance; /**< Lower/upper (constraints') bound tolerance (an inequality constraint whose lower and upper bounds differ by less is regarded to be an equality constraint). */
real_t boundRelaxation; /**< Offset for relaxing (constraints') bounds at beginning of an initial homotopy. It is also as initial value for far bounds. */
real_t epsNum; /**< Numerator tolerance for ratio tests. */
real_t epsDen; /**< Denominator tolerance for ratio tests. */
real_t maxPrimalJump; /**< Maximum allowed jump in primal variables in nonzero curvature tests. */
real_t maxDualJump; /**< Maximum allowed jump in dual variables in linear independence tests. */
real_t initialRamping; /**< Start value for Ramping Strategy. */
real_t finalRamping; /**< Final value for Ramping Strategy. */
real_t initialFarBounds; /**< Initial size of Far Bounds. */
real_t growFarBounds; /**< Factor to grow Far Bounds. */
SubjectToStatus initialStatusBounds; /**< Initial status of bounds at first iteration. */
real_t epsFlipping; /**< Tolerance of squared Cholesky diagonal factor which triggers flipping bound. */
int numRegularisationSteps; /**< Maximum number of successive regularisation steps. */
real_t epsRegularisation; /**< Scaling factor of identity matrix used for Hessian regularisation. */
int numRefinementSteps; /**< Maximum number of iterative refinement steps. */
real_t epsIterRef; /**< Early termination tolerance for iterative refinement. */
real_t epsLITests; /**< Tolerance for linear independence tests. */
real_t epsNZCTests; /**< Tolerance for nonzero curvature tests. */
BooleanType enableDropInfeasibles; /**< ... */
int dropBoundPriority; /**< ... */
int dropEqConPriority; /**< ... */
int dropIneqConPriority; /**< ... */
} Options;
void OptionsCON( Options* _THIS
);
/** Copies all members from given rhs object.
* \return SUCCESSFUL_RETURN */
void OptionsCPY( Options* FROM,
Options* TO
);
/** Sets all options to default values.
* \return SUCCESSFUL_RETURN */
returnValue Options_setToDefault( Options* _THIS
);
/** Sets all options to values resulting in maximum reliabilty.
* \return SUCCESSFUL_RETURN */
returnValue Options_setToReliable( Options* _THIS
);
/** Sets all options to values resulting in minimum solution time.
* \return SUCCESSFUL_RETURN */
returnValue Options_setToMPC( Options* _THIS
);
/** Same as setToMPC( ), for ensuring backwards compatibility.
* \return SUCCESSFUL_RETURN */
returnValue Options_setToFast( Options* _THIS
);
/** Ensures that all options have consistent values by automatically
* adjusting inconsistent ones.
* Note: This routine cannot (and does not try to) ensure that values
* are set to reasonable values that make the QP solution work!
* \return SUCCESSFUL_RETURN \n
* RET_OPTIONS_ADJUSTED */
returnValue Options_ensureConsistency( Options* _THIS
);
/** Prints values of all options.
* \return SUCCESSFUL_RETURN */
returnValue Options_print( Options* _THIS
);
END_NAMESPACE_QPOASES
#endif /* QPOASES_OPTIONS_H */
/*
* end of file
*/
/*
* This file is part of qpOASES.
*
* qpOASES -- An Implementation of the Online Active Set Strategy.
* Copyright (C) 2007-2015 by Hans Joachim Ferreau, Andreas Potschka,
* Christian Kirches et al. All rights reserved.
*
* qpOASES is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* qpOASES is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with qpOASES; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
/**
* \file include/qpOASES_e/Options.h
* \author Hans Joachim Ferreau, Andreas Potschka, Christian Kirches
* \version 3.1embedded
* \date 2007-2015
*
* Declaration of the Options class designed to manage user-specified
* options for solving a QProblem.
*/
#ifndef QPOASES_OPTIONS_H
#define QPOASES_OPTIONS_H
#include <qpOASES_e/Utils.h>
BEGIN_NAMESPACE_QPOASES
/**
* \brief Manages all user-specified options for solving QPs.
*
* This class manages all user-specified options used for solving
* quadratic programs.
*
* \author Hans Joachim Ferreau, Andreas Potschka, Christian Kirches
* \version 3.1embedded
* \date 2007-2015
*/
typedef struct
{
PrintLevel printLevel; /**< Print level. */
BooleanType enableRamping; /**< Specifies whether ramping shall be enabled or not. */
BooleanType enableFarBounds; /**< Specifies whether far bounds shall be used or not. */
BooleanType enableFlippingBounds; /**< Specifies whether flipping bounds shall be used or not. */
BooleanType enableRegularisation; /**< Specifies whether Hessian matrix shall be regularised in case semi-definiteness is detected. */
BooleanType enableFullLITests; /**< Specifies whether condition-hardened LI test shall be used or not. */
BooleanType enableNZCTests; /**< Specifies whether nonzero curvature tests shall be used. */
int enableDriftCorrection; /**< Specifies the frequency of drift corrections (0 = off). */
int enableCholeskyRefactorisation; /**< Specifies the frequency of full refactorisation of proj. Hessian (otherwise updates). */
BooleanType enableEqualities; /**< Specifies whether equalities shall be always treated as active constraints. */
real_t terminationTolerance; /**< Termination tolerance. */
real_t boundTolerance; /**< Lower/upper (constraints') bound tolerance (an inequality constraint whose lower and upper bounds differ by less is regarded to be an equality constraint). */
real_t boundRelaxation; /**< Offset for relaxing (constraints') bounds at beginning of an initial homotopy. It is also as initial value for far bounds. */
real_t epsNum; /**< Numerator tolerance for ratio tests. */
real_t epsDen; /**< Denominator tolerance for ratio tests. */
real_t maxPrimalJump; /**< Maximum allowed jump in primal variables in nonzero curvature tests. */
real_t maxDualJump; /**< Maximum allowed jump in dual variables in linear independence tests. */
real_t initialRamping; /**< Start value for Ramping Strategy. */
real_t finalRamping; /**< Final value for Ramping Strategy. */
real_t initialFarBounds; /**< Initial size of Far Bounds. */
real_t growFarBounds; /**< Factor to grow Far Bounds. */
SubjectToStatus initialStatusBounds; /**< Initial status of bounds at first iteration. */
real_t epsFlipping; /**< Tolerance of squared Cholesky diagonal factor which triggers flipping bound. */
int numRegularisationSteps; /**< Maximum number of successive regularisation steps. */
real_t epsRegularisation; /**< Scaling factor of identity matrix used for Hessian regularisation. */
int numRefinementSteps; /**< Maximum number of iterative refinement steps. */
real_t epsIterRef; /**< Early termination tolerance for iterative refinement. */
real_t epsLITests; /**< Tolerance for linear independence tests. */
real_t epsNZCTests; /**< Tolerance for nonzero curvature tests. */
BooleanType enableDropInfeasibles; /**< ... */
int dropBoundPriority; /**< ... */
int dropEqConPriority; /**< ... */
int dropIneqConPriority; /**< ... */
} Options;
void OptionsCON( Options* _THIS
);
/** Copies all members from given rhs object.
* \return SUCCESSFUL_RETURN */
void OptionsCPY( Options* FROM,
Options* TO
);
/** Sets all options to default values.
* \return SUCCESSFUL_RETURN */
returnValue Options_setToDefault( Options* _THIS
);
/** Sets all options to values resulting in maximum reliabilty.
* \return SUCCESSFUL_RETURN */
returnValue Options_setToReliable( Options* _THIS
);
/** Sets all options to values resulting in minimum solution time.
* \return SUCCESSFUL_RETURN */
returnValue Options_setToMPC( Options* _THIS
);
/** Same as setToMPC( ), for ensuring backwards compatibility.
* \return SUCCESSFUL_RETURN */
returnValue Options_setToFast( Options* _THIS
);
/** Ensures that all options have consistent values by automatically
* adjusting inconsistent ones.
* Note: This routine cannot (and does not try to) ensure that values
* are set to reasonable values that make the QP solution work!
* \return SUCCESSFUL_RETURN \n
* RET_OPTIONS_ADJUSTED */
returnValue Options_ensureConsistency( Options* _THIS
);
/** Prints values of all options.
* \return SUCCESSFUL_RETURN */
returnValue Options_print( Options* _THIS
);
END_NAMESPACE_QPOASES
#endif /* QPOASES_OPTIONS_H */
/*
* end of file
*/

4738
third_party/acados/include/qpOASES_e/QProblem.h vendored
View File

File diff suppressed because it is too large Load Diff

620
third_party/acados/include/qpOASES_e/Types.h vendored
Unescape View File

@ -1,310 +1,310 @@
/*
* This file is part of qpOASES.
*
* qpOASES -- An Implementation of the Online Active Set Strategy.
* Copyright (C) 2007-2015 by Hans Joachim Ferreau, Andreas Potschka,
* Christian Kirches et al. All rights reserved.
*
* qpOASES is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* qpOASES is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with qpOASES; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
/**
* \file include/qpOASES_e/Types.h
* \author Hans Joachim Ferreau, Andreas Potschka, Christian Kirches
* \version 3.1embedded
* \date 2007-2015
*
* Declaration of all non-built-in types (except for classes).
*/
#ifndef QPOASES_TYPES_H
#define QPOASES_TYPES_H
#ifdef USE_ACADOS_TYPES
#include "acados/utils/types.h"
#endif
/* If your compiler does not support the snprintf() function,
* uncomment the following line and try to compile again. */
/* #define __NO_SNPRINTF__ */
/* Uncomment the following line for setting the __DSPACE__ flag. */
/* #define __DSPACE__ */
/* Uncomment the following line for setting the __XPCTARGET__ flag. */
/* #define __XPCTARGET__ */
/* Uncomment the following line for setting the __NO_FMATH__ flag. */
/* #define __NO_FMATH__ */
/* Uncomment the following line to enable debug information. */
/* #define __DEBUG__ */
/* Uncomment the following line to enable suppress any kind of console output. */
/* #define __SUPPRESSANYOUTPUT__ */
/** Forces to always include all implicitly fixed bounds and all equality constraints
* into the initial working set when setting up an auxiliary QP. */
#define __ALWAYS_INITIALISE_WITH_ALL_EQUALITIES__
/* Uncomment the following line to activate the use of an alternative Givens
* plane rotation requiring only three multiplications. */
/* #define __USE_THREE_MULTS_GIVENS__ */
/* Uncomment the following line to activate the use of single precision arithmetic. */
/* #define __USE_SINGLE_PRECISION__ */
/* The inline keyword is skipped by default as it is not part of the C90 standard.
* However, by uncommenting the following line, use of the inline keyword can be enforced. */
/* #define __USE_INLINE__ */
/* Work-around for Borland BCC 5.5 compiler. */
#ifdef __BORLANDC__
#if __BORLANDC__ < 0x0561
#define __STDC__ 1
#endif
#endif
/* Work-around for Microsoft compilers. */
#ifdef _MSC_VER
#define __NO_SNPRINTF__
#pragma warning( disable : 4061 4100 4250 4514 4996 )
#endif
/* Apply pre-processor settings when using qpOASES within auto-generated code. */
#ifdef __CODE_GENERATION__
#define __NO_COPYRIGHT__
#define __EXTERNAL_DIMENSIONS__
#endif /* __CODE_GENERATION__ */
/* Avoid using static variables declaration within functions. */
#ifdef __NO_STATIC__
#define myStatic
#else
#define myStatic static
#endif /* __NO_STATIC__ */
/* Skip inline keyword if not specified otherwise. */
#ifndef __USE_INLINE__
#define inline
#endif
/* Avoid any printing on embedded platforms. */
#if defined(__DSPACE__) || defined(__XPCTARGET__)
#define __SUPPRESSANYOUTPUT__
#define __NO_SNPRINTF__
#endif
#ifdef __NO_SNPRINTF__
#if (!defined(_MSC_VER)) || defined(__DSPACE__) || defined(__XPCTARGET__)
/* If snprintf is not available, provide an empty implementation... */
int snprintf( char* s, size_t n, const char* format, ... );
#else
/* ... or substitute snprintf by _snprintf for Microsoft compilers. */
#define snprintf _snprintf
#endif
#endif /* __NO_SNPRINTF__ */
/** Macro for switching on/off the beginning of the qpOASES namespace definition. */
#define BEGIN_NAMESPACE_QPOASES
/** Macro for switching on/off the end of the qpOASES namespace definition. */
#define END_NAMESPACE_QPOASES
/** Macro for switching on/off the use of the qpOASES namespace. */
#define USING_NAMESPACE_QPOASES
/** Macro for switching on/off references to the qpOASES namespace. */
#define REFER_NAMESPACE_QPOASES /*::*/
/** Macro for accessing the Cholesky factor R. */
#define RR( I,J ) _THIS->R[(I)+nV*(J)]
/** Macro for accessing the orthonormal matrix Q of the QT factorisation. */
#define QQ( I,J ) _THIS->Q[(I)+nV*(J)]
/** Macro for accessing the triangular matrix T of the QT factorisation. */
#define TT( I,J ) _THIS->T[(I)*nVC_min+(J)]
BEGIN_NAMESPACE_QPOASES
/** Defines real_t for facilitating switching between double and float. */
#ifndef USE_ACADOS_TYPES
#ifndef __CODE_GENERATION__
#ifdef __USE_SINGLE_PRECISION__
typedef float real_t;
#else
typedef double real_t;
#endif /* __USE_SINGLE_PRECISION__ */
#endif /* __CODE_GENERATION__ */
#endif /* USE_ACADOS_TYPES */
/** Summarises all possible logical values. */
typedef enum
{
BT_FALSE = 0, /**< Logical value for "false". */
BT_TRUE /**< Logical value for "true". */
} BooleanType;
/** Summarises all possible print levels. Print levels are used to describe
* the desired amount of output during runtime of qpOASES. */
typedef enum
{
PL_DEBUG_ITER = -2, /**< Full tabular debugging output. */
PL_TABULAR, /**< Tabular output. */
PL_NONE, /**< No output. */
PL_LOW, /**< Print error messages only. */
PL_MEDIUM, /**< Print error and warning messages as well as concise info messages. */
PL_HIGH /**< Print all messages with full details. */
} PrintLevel;
/** Defines visibility status of a message. */
typedef enum
{
VS_HIDDEN, /**< Message not visible. */
VS_VISIBLE /**< Message visible. */
} VisibilityStatus;
/** Summarises all possible states of the (S)QProblem(B) object during the
solution process of a QP sequence. */
typedef enum
{
QPS_NOTINITIALISED, /**< QProblem object is freshly instantiated or reset. */
QPS_PREPARINGAUXILIARYQP, /**< An auxiliary problem is currently setup, either at the very beginning
* via an initial homotopy or after changing the QP matrices. */
QPS_AUXILIARYQPSOLVED, /**< An auxilary problem was solved, either at the very beginning
* via an initial homotopy or after changing the QP matrices. */
QPS_PERFORMINGHOMOTOPY, /**< A homotopy according to the main idea of the online active
* set strategy is performed. */
QPS_HOMOTOPYQPSOLVED, /**< An intermediate QP along the homotopy path was solved. */
QPS_SOLVED /**< The solution of the actual QP was found. */
} QProblemStatus;
/** Summarises all possible types of the QP's Hessian matrix. */
typedef enum
{
HST_ZERO, /**< Hessian is zero matrix (i.e. LP formulation). */
HST_IDENTITY, /**< Hessian is identity matrix. */
HST_POSDEF, /**< Hessian is (strictly) positive definite. */
HST_POSDEF_NULLSPACE, /**< Hessian is positive definite on null space of active bounds/constraints. */
HST_SEMIDEF, /**< Hessian is positive semi-definite. */
HST_INDEF, /**< Hessian is indefinite. */
HST_UNKNOWN /**< Hessian type is unknown. */
} HessianType;
/** Summarises all possible types of bounds and constraints. */
typedef enum
{
ST_UNBOUNDED, /**< Bound/constraint is unbounded. */
ST_BOUNDED, /**< Bound/constraint is bounded but not fixed. */
ST_EQUALITY, /**< Bound/constraint is fixed (implicit equality bound/constraint). */
ST_DISABLED, /**< Bound/constraint is disabled (i.e. ignored when solving QP). */
ST_UNKNOWN /**< Type of bound/constraint unknown. */
} SubjectToType;
/** Summarises all possible states of bounds and constraints. */
typedef enum
{
ST_LOWER = -1, /**< Bound/constraint is at its lower bound. */
ST_INACTIVE, /**< Bound/constraint is inactive. */
ST_UPPER, /**< Bound/constraint is at its upper bound. */
ST_INFEASIBLE_LOWER, /**< (to be documented) */
ST_INFEASIBLE_UPPER, /**< (to be documented) */
ST_UNDEFINED /**< Status of bound/constraint undefined. */
} SubjectToStatus;
/**
* \brief Stores internal information for tabular (debugging) output.
*
* Struct storing internal information for tabular (debugging) output
* when using the (S)QProblem(B) objects.
*
* \author Hans Joachim Ferreau
* \version 3.1embedded
* \date 2013-2015
*/
typedef struct
{
int idxAddB; /**< Index of bound that has been added to working set. */
int idxRemB; /**< Index of bound that has been removed from working set. */
int idxAddC; /**< Index of constraint that has been added to working set. */
int idxRemC; /**< Index of constraint that has been removed from working set. */
int excAddB; /**< Flag indicating whether a bound has been added to working set to keep a regular projected Hessian. */
int excRemB; /**< Flag indicating whether a bound has been removed from working set to keep a regular projected Hessian. */
int excAddC; /**< Flag indicating whether a constraint has been added to working set to keep a regular projected Hessian. */
int excRemC; /**< Flag indicating whether a constraint has been removed from working set to keep a regular projected Hessian. */
} TabularOutput;
/**
* \brief Struct containing the variable header for mat file.
*
* Struct storing the header of a variable to be stored in
* Matlab's binary format (using the outdated Level 4 variant
* for simplictiy).
*
* Note, this code snippet has been inspired from the document
* "Matlab(R) MAT-file Format, R2013b" by MathWorks
*
* \author Hans Joachim Ferreau
* \version 3.1embedded
* \date 2013-2015
*/
typedef struct
{
long numericFormat; /**< Flag indicating numerical format. */
long nRows; /**< Number of rows. */
long nCols; /**< Number of rows. */
long imaginaryPart; /**< (to be documented) */
long nCharName; /**< Number of character in name. */
} MatMatrixHeader;
END_NAMESPACE_QPOASES
#endif /* QPOASES_TYPES_H */
/*
* end of file
*/
/*
* This file is part of qpOASES.
*
* qpOASES -- An Implementation of the Online Active Set Strategy.
* Copyright (C) 2007-2015 by Hans Joachim Ferreau, Andreas Potschka,
* Christian Kirches et al. All rights reserved.
*
* qpOASES is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* qpOASES is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with qpOASES; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
/**
* \file include/qpOASES_e/Types.h
* \author Hans Joachim Ferreau, Andreas Potschka, Christian Kirches
* \version 3.1embedded
* \date 2007-2015
*
* Declaration of all non-built-in types (except for classes).
*/
#ifndef QPOASES_TYPES_H
#define QPOASES_TYPES_H
#ifdef USE_ACADOS_TYPES
#include "acados/utils/types.h"
#endif
/* If your compiler does not support the snprintf() function,
* uncomment the following line and try to compile again. */
/* #define __NO_SNPRINTF__ */
/* Uncomment the following line for setting the __DSPACE__ flag. */
/* #define __DSPACE__ */
/* Uncomment the following line for setting the __XPCTARGET__ flag. */
/* #define __XPCTARGET__ */
/* Uncomment the following line for setting the __NO_FMATH__ flag. */
/* #define __NO_FMATH__ */
/* Uncomment the following line to enable debug information. */
/* #define __DEBUG__ */
/* Uncomment the following line to enable suppress any kind of console output. */
/* #define __SUPPRESSANYOUTPUT__ */
/** Forces to always include all implicitly fixed bounds and all equality constraints
* into the initial working set when setting up an auxiliary QP. */
#define __ALWAYS_INITIALISE_WITH_ALL_EQUALITIES__
/* Uncomment the following line to activate the use of an alternative Givens
* plane rotation requiring only three multiplications. */
/* #define __USE_THREE_MULTS_GIVENS__ */
/* Uncomment the following line to activate the use of single precision arithmetic. */
/* #define __USE_SINGLE_PRECISION__ */
/* The inline keyword is skipped by default as it is not part of the C90 standard.
* However, by uncommenting the following line, use of the inline keyword can be enforced. */
/* #define __USE_INLINE__ */
/* Work-around for Borland BCC 5.5 compiler. */
#ifdef __BORLANDC__
#if __BORLANDC__ < 0x0561
#define __STDC__ 1
#endif
#endif
/* Work-around for Microsoft compilers. */
#ifdef _MSC_VER
#define __NO_SNPRINTF__
#pragma warning( disable : 4061 4100 4250 4514 4996 )
#endif
/* Apply pre-processor settings when using qpOASES within auto-generated code. */
#ifdef __CODE_GENERATION__
#define __NO_COPYRIGHT__
#define __EXTERNAL_DIMENSIONS__
#endif /* __CODE_GENERATION__ */
/* Avoid using static variables declaration within functions. */
#ifdef __NO_STATIC__
#define myStatic
#else
#define myStatic static
#endif /* __NO_STATIC__ */
/* Skip inline keyword if not specified otherwise. */
#ifndef __USE_INLINE__
#define inline
#endif
/* Avoid any printing on embedded platforms. */
#if defined(__DSPACE__) || defined(__XPCTARGET__)
#define __SUPPRESSANYOUTPUT__
#define __NO_SNPRINTF__
#endif
#ifdef __NO_SNPRINTF__
#if (!defined(_MSC_VER)) || defined(__DSPACE__) || defined(__XPCTARGET__)
/* If snprintf is not available, provide an empty implementation... */
int snprintf( char* s, size_t n, const char* format, ... );
#else
/* ... or substitute snprintf by _snprintf for Microsoft compilers. */
#define snprintf _snprintf
#endif
#endif /* __NO_SNPRINTF__ */
/** Macro for switching on/off the beginning of the qpOASES namespace definition. */
#define BEGIN_NAMESPACE_QPOASES
/** Macro for switching on/off the end of the qpOASES namespace definition. */
#define END_NAMESPACE_QPOASES
/** Macro for switching on/off the use of the qpOASES namespace. */
#define USING_NAMESPACE_QPOASES
/** Macro for switching on/off references to the qpOASES namespace. */
#define REFER_NAMESPACE_QPOASES /*::*/
/** Macro for accessing the Cholesky factor R. */
#define RR( I,J ) _THIS->R[(I)+nV*(J)]
/** Macro for accessing the orthonormal matrix Q of the QT factorisation. */
#define QQ( I,J ) _THIS->Q[(I)+nV*(J)]
/** Macro for accessing the triangular matrix T of the QT factorisation. */
#define TT( I,J ) _THIS->T[(I)*nVC_min+(J)]
BEGIN_NAMESPACE_QPOASES
/** Defines real_t for facilitating switching between double and float. */
#ifndef USE_ACADOS_TYPES
#ifndef __CODE_GENERATION__
#ifdef __USE_SINGLE_PRECISION__
typedef float real_t;
#else
typedef double real_t;
#endif /* __USE_SINGLE_PRECISION__ */
#endif /* __CODE_GENERATION__ */
#endif /* USE_ACADOS_TYPES */
/** Summarises all possible logical values. */
typedef enum
{
BT_FALSE = 0, /**< Logical value for "false". */
BT_TRUE /**< Logical value for "true". */
} BooleanType;
/** Summarises all possible print levels. Print levels are used to describe
* the desired amount of output during runtime of qpOASES. */
typedef enum
{
PL_DEBUG_ITER = -2, /**< Full tabular debugging output. */
PL_TABULAR, /**< Tabular output. */
PL_NONE, /**< No output. */
PL_LOW, /**< Print error messages only. */
PL_MEDIUM, /**< Print error and warning messages as well as concise info messages. */
PL_HIGH /**< Print all messages with full details. */
} PrintLevel;
/** Defines visibility status of a message. */
typedef enum
{
VS_HIDDEN, /**< Message not visible. */
VS_VISIBLE /**< Message visible. */
} VisibilityStatus;
/** Summarises all possible states of the (S)QProblem(B) object during the
solution process of a QP sequence. */
typedef enum
{
QPS_NOTINITIALISED, /**< QProblem object is freshly instantiated or reset. */
QPS_PREPARINGAUXILIARYQP, /**< An auxiliary problem is currently setup, either at the very beginning
* via an initial homotopy or after changing the QP matrices. */
QPS_AUXILIARYQPSOLVED, /**< An auxilary problem was solved, either at the very beginning
* via an initial homotopy or after changing the QP matrices. */
QPS_PERFORMINGHOMOTOPY, /**< A homotopy according to the main idea of the online active
* set strategy is performed. */
QPS_HOMOTOPYQPSOLVED, /**< An intermediate QP along the homotopy path was solved. */
QPS_SOLVED /**< The solution of the actual QP was found. */
} QProblemStatus;
/** Summarises all possible types of the QP's Hessian matrix. */
typedef enum
{
HST_ZERO, /**< Hessian is zero matrix (i.e. LP formulation). */
HST_IDENTITY, /**< Hessian is identity matrix. */
HST_POSDEF, /**< Hessian is (strictly) positive definite. */
HST_POSDEF_NULLSPACE, /**< Hessian is positive definite on null space of active bounds/constraints. */
HST_SEMIDEF, /**< Hessian is positive semi-definite. */
HST_INDEF, /**< Hessian is indefinite. */
HST_UNKNOWN /**< Hessian type is unknown. */
} HessianType;
/** Summarises all possible types of bounds and constraints. */
typedef enum
{
ST_UNBOUNDED, /**< Bound/constraint is unbounded. */
ST_BOUNDED, /**< Bound/constraint is bounded but not fixed. */
ST_EQUALITY, /**< Bound/constraint is fixed (implicit equality bound/constraint). */
ST_DISABLED, /**< Bound/constraint is disabled (i.e. ignored when solving QP). */
ST_UNKNOWN /**< Type of bound/constraint unknown. */
} SubjectToType;
/** Summarises all possible states of bounds and constraints. */
typedef enum
{
ST_LOWER = -1, /**< Bound/constraint is at its lower bound. */
ST_INACTIVE, /**< Bound/constraint is inactive. */
ST_UPPER, /**< Bound/constraint is at its upper bound. */
ST_INFEASIBLE_LOWER, /**< (to be documented) */
ST_INFEASIBLE_UPPER, /**< (to be documented) */
ST_UNDEFINED /**< Status of bound/constraint undefined. */
} SubjectToStatus;
/**
* \brief Stores internal information for tabular (debugging) output.
*
* Struct storing internal information for tabular (debugging) output
* when using the (S)QProblem(B) objects.
*
* \author Hans Joachim Ferreau
* \version 3.1embedded
* \date 2013-2015
*/
typedef struct
{
int idxAddB; /**< Index of bound that has been added to working set. */
int idxRemB; /**< Index of bound that has been removed from working set. */
int idxAddC; /**< Index of constraint that has been added to working set. */
int idxRemC; /**< Index of constraint that has been removed from working set. */
int excAddB; /**< Flag indicating whether a bound has been added to working set to keep a regular projected Hessian. */
int excRemB; /**< Flag indicating whether a bound has been removed from working set to keep a regular projected Hessian. */
int excAddC; /**< Flag indicating whether a constraint has been added to working set to keep a regular projected Hessian. */
int excRemC; /**< Flag indicating whether a constraint has been removed from working set to keep a regular projected Hessian. */
} TabularOutput;
/**
* \brief Struct containing the variable header for mat file.
*
* Struct storing the header of a variable to be stored in
* Matlab's binary format (using the outdated Level 4 variant
* for simplictiy).
*
* Note, this code snippet has been inspired from the document
* "Matlab(R) MAT-file Format, R2013b" by MathWorks
*
* \author Hans Joachim Ferreau
* \version 3.1embedded
* \date 2013-2015
*/
typedef struct
{
long numericFormat; /**< Flag indicating numerical format. */
long nRows; /**< Number of rows. */
long nCols; /**< Number of rows. */
long imaginaryPart; /**< (to be documented) */
long nCharName; /**< Number of character in name. */
} MatMatrixHeader;
END_NAMESPACE_QPOASES
#endif /* QPOASES_TYPES_H */
/*
* end of file
*/

158
third_party/acados/include/qpOASES_e/UnitTesting.h vendored
Unescape View File

@ -1,79 +1,79 @@
/*
* This file is part of qpOASES.
*
* qpOASES -- An Implementation of the Online Active Set Strategy.
* Copyright (C) 2007-2015 by Hans Joachim Ferreau, Andreas Potschka,
* Christian Kirches et al. All rights reserved.
*
* qpOASES is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* qpOASES is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with qpOASES; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
/**
* \file include/qpOASES_e/UnitTesting.h
* \author Hans Joachim Ferreau
* \version 3.1embedded
* \date 2014-2015
*
* Definition of auxiliary functions/macros for unit testing.
*/
#ifndef QPOASES_UNIT_TESTING_H
#define QPOASES_UNIT_TESTING_H
#ifndef TEST_TOL_FACTOR
#define TEST_TOL_FACTOR 1
#endif
/** Return value for tests that passed. */
#define TEST_PASSED 0
/** Return value for tests that failed. */
#define TEST_FAILED 1
/** Return value for tests that could not run due to missing external data. */
#define TEST_DATA_NOT_FOUND 99
/** Macro verifying that two numerical values are equal in order to pass unit test. */
#define QPOASES_TEST_FOR_EQUAL( x,y ) if ( REFER_NAMESPACE_QPOASES isEqual( (x),(y) ) == BT_FALSE ) { return TEST_FAILED; }
/** Macro verifying that two numerical values are close to each other in order to pass unit test. */
#define QPOASES_TEST_FOR_NEAR( x,y ) if ( REFER_NAMESPACE_QPOASES getAbs((x)-(y)) / REFER_NAMESPACE_QPOASES getMax( 1.0,REFER_NAMESPACE_QPOASES getAbs(x) ) >= 1e-10 ) { return TEST_FAILED; }
/** Macro verifying that first quantity is lower or equal than second one in order to pass unit test. */
#define QPOASES_TEST_FOR_TOL( x,tol ) if ( (x) > (tol)*(TEST_TOL_FACTOR) ) { return TEST_FAILED; }
/** Macro verifying that a logical expression holds in order to pass unit test. */
#define QPOASES_TEST_FOR_TRUE( x ) if ( (x) == 0 ) { return TEST_FAILED; }
BEGIN_NAMESPACE_QPOASES
END_NAMESPACE_QPOASES
#endif /* QPOASES_UNIT_TESTING_H */
/*
* end of file
*/
/*
* This file is part of qpOASES.
*
* qpOASES -- An Implementation of the Online Active Set Strategy.
* Copyright (C) 2007-2015 by Hans Joachim Ferreau, Andreas Potschka,
* Christian Kirches et al. All rights reserved.
*
* qpOASES is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* qpOASES is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with qpOASES; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
/**
* \file include/qpOASES_e/UnitTesting.h
* \author Hans Joachim Ferreau
* \version 3.1embedded
* \date 2014-2015
*
* Definition of auxiliary functions/macros for unit testing.
*/
#ifndef QPOASES_UNIT_TESTING_H
#define QPOASES_UNIT_TESTING_H
#ifndef TEST_TOL_FACTOR
#define TEST_TOL_FACTOR 1
#endif
/** Return value for tests that passed. */
#define TEST_PASSED 0
/** Return value for tests that failed. */
#define TEST_FAILED 1
/** Return value for tests that could not run due to missing external data. */
#define TEST_DATA_NOT_FOUND 99
/** Macro verifying that two numerical values are equal in order to pass unit test. */
#define QPOASES_TEST_FOR_EQUAL( x,y ) if ( REFER_NAMESPACE_QPOASES isEqual( (x),(y) ) == BT_FALSE ) { return TEST_FAILED; }
/** Macro verifying that two numerical values are close to each other in order to pass unit test. */
#define QPOASES_TEST_FOR_NEAR( x,y ) if ( REFER_NAMESPACE_QPOASES getAbs((x)-(y)) / REFER_NAMESPACE_QPOASES getMax( 1.0,REFER_NAMESPACE_QPOASES getAbs(x) ) >= 1e-10 ) { return TEST_FAILED; }
/** Macro verifying that first quantity is lower or equal than second one in order to pass unit test. */
#define QPOASES_TEST_FOR_TOL( x,tol ) if ( (x) > (tol)*(TEST_TOL_FACTOR) ) { return TEST_FAILED; }
/** Macro verifying that a logical expression holds in order to pass unit test. */
#define QPOASES_TEST_FOR_TRUE( x ) if ( (x) == 0 ) { return TEST_FAILED; }
BEGIN_NAMESPACE_QPOASES
END_NAMESPACE_QPOASES
#endif /* QPOASES_UNIT_TESTING_H */
/*
* end of file
*/

124
third_party/catch2/include/catch2/catch_reporter_automake.hpp vendored
Unescape View File

@ -1,62 +1,62 @@
/*
* Created by Justin R. Wilson on 2/19/2017.
* Copyright 2017 Justin R. Wilson. All rights reserved.
*
* Distributed under the Boost Software License, Version 1.0. (See accompanying
* file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
#define TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
// Don't #include any Catch headers here - we can assume they are already
// included before this header.
// This is not good practice in general but is necessary in this case so this
// file can be distributed as a single header that works with the main
// Catch single header.
namespace Catch {
struct AutomakeReporter : StreamingReporterBase<AutomakeReporter> {
AutomakeReporter( ReporterConfig const& _config )
: StreamingReporterBase( _config )
{}
~AutomakeReporter() override;
static std::string getDescription() {
return "Reports test results in the format of Automake .trs files";
}
void assertionStarting( AssertionInfo const& ) override {}
bool assertionEnded( AssertionStats const& /*_assertionStats*/ ) override { return true; }
void testCaseEnded( TestCaseStats const& _testCaseStats ) override {
// Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR.
stream << ":test-result: ";
if (_testCaseStats.totals.assertions.allPassed()) {
stream << "PASS";
} else if (_testCaseStats.totals.assertions.allOk()) {
stream << "XFAIL";
} else {
stream << "FAIL";
}
stream << ' ' << _testCaseStats.testInfo.name << '\n';
StreamingReporterBase::testCaseEnded( _testCaseStats );
}
void skipTest( TestCaseInfo const& testInfo ) override {
stream << ":test-result: SKIP " << testInfo.name << '\n';
}
};
#ifdef CATCH_IMPL
AutomakeReporter::~AutomakeReporter() {}
#endif
CATCH_REGISTER_REPORTER( "automake", AutomakeReporter)
} // end namespace Catch
#endif // TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
/*
* Created by Justin R. Wilson on 2/19/2017.
* Copyright 2017 Justin R. Wilson. All rights reserved.
*
* Distributed under the Boost Software License, Version 1.0. (See accompanying
* file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
#define TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
// Don't #include any Catch headers here - we can assume they are already
// included before this header.
// This is not good practice in general but is necessary in this case so this
// file can be distributed as a single header that works with the main
// Catch single header.
namespace Catch {
struct AutomakeReporter : StreamingReporterBase<AutomakeReporter> {
AutomakeReporter( ReporterConfig const& _config )
: StreamingReporterBase( _config )
{}
~AutomakeReporter() override;
static std::string getDescription() {
return "Reports test results in the format of Automake .trs files";
}
void assertionStarting( AssertionInfo const& ) override {}
bool assertionEnded( AssertionStats const& /*_assertionStats*/ ) override { return true; }
void testCaseEnded( TestCaseStats const& _testCaseStats ) override {
// Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR.
stream << ":test-result: ";
if (_testCaseStats.totals.assertions.allPassed()) {
stream << "PASS";
} else if (_testCaseStats.totals.assertions.allOk()) {
stream << "XFAIL";
} else {
stream << "FAIL";
}
stream << ' ' << _testCaseStats.testInfo.name << '\n';
StreamingReporterBase::testCaseEnded( _testCaseStats );
}
void skipTest( TestCaseInfo const& testInfo ) override {
stream << ":test-result: SKIP " << testInfo.name << '\n';
}
};
#ifdef CATCH_IMPL
AutomakeReporter::~AutomakeReporter() {}
#endif
CATCH_REGISTER_REPORTER( "automake", AutomakeReporter)
} // end namespace Catch
#endif // TWOBLUECUBES_CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED

360
third_party/catch2/include/catch2/catch_reporter_sonarqube.hpp vendored
Unescape View File

@ -1,181 +1,181 @@
/*
* Created by Daniel Garcia on 2018-12-04.
* Copyright Social Point SL. All rights reserved.
*
* Distributed under the Boost Software License, Version 1.0. (See accompanying
* file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
#define CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
// Don't #include any Catch headers here - we can assume they are already
// included before this header.
// This is not good practice in general but is necessary in this case so this
// file can be distributed as a single header that works with the main
// Catch single header.
#include <map>
namespace Catch {
struct SonarQubeReporter : CumulativeReporterBase<SonarQubeReporter> {
SonarQubeReporter(ReporterConfig const& config)
: CumulativeReporterBase(config)
, xml(config.stream()) {
m_reporterPrefs.shouldRedirectStdOut = true;
m_reporterPrefs.shouldReportAllAssertions = true;
}
~SonarQubeReporter() override;
static std::string getDescription() {
return "Reports test results in the Generic Test Data SonarQube XML format";
}
static std::set<Verbosity> getSupportedVerbosities() {
return { Verbosity::Normal };
}
void noMatchingTestCases(std::string const& /*spec*/) override {}
void testRunStarting(TestRunInfo const& testRunInfo) override {
CumulativeReporterBase::testRunStarting(testRunInfo);
xml.startElement("testExecutions");
xml.writeAttribute("version", "1");
}
void testGroupEnded(TestGroupStats const& testGroupStats) override {
CumulativeReporterBase::testGroupEnded(testGroupStats);
writeGroup(*m_testGroups.back());
}
void testRunEndedCumulative() override {
xml.endElement();
}
void writeGroup(TestGroupNode const& groupNode) {
std::map<std::string, TestGroupNode::ChildNodes> testsPerFile;
for(auto const& child : groupNode.children)
testsPerFile[child->value.testInfo.lineInfo.file].push_back(child);
for(auto const& kv : testsPerFile)
writeTestFile(kv.first.c_str(), kv.second);
}
void writeTestFile(const char* filename, TestGroupNode::ChildNodes const& testCaseNodes) {
XmlWriter::ScopedElement e = xml.scopedElement("file");
xml.writeAttribute("path", filename);
for(auto const& child : testCaseNodes)
writeTestCase(*child);
}
void writeTestCase(TestCaseNode const& testCaseNode) {
// All test cases have exactly one section - which represents the
// test case itself. That section may have 0-n nested sections
assert(testCaseNode.children.size() == 1);
SectionNode const& rootSection = *testCaseNode.children.front();
writeSection("", rootSection, testCaseNode.value.testInfo.okToFail());
}
void writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail) {
std::string name = trim(sectionNode.stats.sectionInfo.name);
if(!rootName.empty())
name = rootName + '/' + name;
if(!sectionNode.assertions.empty() || !sectionNode.stdOut.empty() || !sectionNode.stdErr.empty()) {
XmlWriter::ScopedElement e = xml.scopedElement("testCase");
xml.writeAttribute("name", name);
xml.writeAttribute("duration", static_cast<long>(sectionNode.stats.durationInSeconds * 1000));
writeAssertions(sectionNode, okToFail);
}
for(auto const& childNode : sectionNode.childSections)
writeSection(name, *childNode, okToFail);
}
void writeAssertions(SectionNode const& sectionNode, bool okToFail) {
for(auto const& assertion : sectionNode.assertions)
writeAssertion( assertion, okToFail);
}
void writeAssertion(AssertionStats const& stats, bool okToFail) {
AssertionResult const& result = stats.assertionResult;
if(!result.isOk()) {
std::string elementName;
if(okToFail) {
elementName = "skipped";
}
else {
switch(result.getResultType()) {
case ResultWas::ThrewException:
case ResultWas::FatalErrorCondition:
elementName = "error";
break;
case ResultWas::ExplicitFailure:
elementName = "failure";
break;
case ResultWas::ExpressionFailed:
elementName = "failure";
break;
case ResultWas::DidntThrowException:
elementName = "failure";
break;
// We should never see these here:
case ResultWas::Info:
case ResultWas::Warning:
case ResultWas::Ok:
case ResultWas::Unknown:
case ResultWas::FailureBit:
case ResultWas::Exception:
elementName = "internalError";
break;
}
}
XmlWriter::ScopedElement e = xml.scopedElement(elementName);
ReusableStringStream messageRss;
messageRss << result.getTestMacroName() << "(" << result.getExpression() << ")";
xml.writeAttribute("message", messageRss.str());
ReusableStringStream textRss;
if (stats.totals.assertions.total() > 0) {
textRss << "FAILED:\n";
if (result.hasExpression()) {
textRss << "\t" << result.getExpressionInMacro() << "\n";
}
if (result.hasExpandedExpression()) {
textRss << "with expansion:\n\t" << result.getExpandedExpression() << "\n";
}
}
if(!result.getMessage().empty())
textRss << result.getMessage() << "\n";
for(auto const& msg : stats.infoMessages)
if(msg.type == ResultWas::Info)
textRss << msg.message << "\n";
textRss << "at " << result.getSourceInfo();
xml.writeText(textRss.str(), XmlFormatting::Newline);
}
}
private:
XmlWriter xml;
};
#ifdef CATCH_IMPL
SonarQubeReporter::~SonarQubeReporter() {}
#endif
CATCH_REGISTER_REPORTER( "sonarqube", SonarQubeReporter )
} // end namespace Catch
/*
* Created by Daniel Garcia on 2018-12-04.
* Copyright Social Point SL. All rights reserved.
*
* Distributed under the Boost Software License, Version 1.0. (See accompanying
* file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
#define CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
// Don't #include any Catch headers here - we can assume they are already
// included before this header.
// This is not good practice in general but is necessary in this case so this
// file can be distributed as a single header that works with the main
// Catch single header.
#include <map>
namespace Catch {
struct SonarQubeReporter : CumulativeReporterBase<SonarQubeReporter> {
SonarQubeReporter(ReporterConfig const& config)
: CumulativeReporterBase(config)
, xml(config.stream()) {
m_reporterPrefs.shouldRedirectStdOut = true;
m_reporterPrefs.shouldReportAllAssertions = true;
}
~SonarQubeReporter() override;
static std::string getDescription() {
return "Reports test results in the Generic Test Data SonarQube XML format";
}
static std::set<Verbosity> getSupportedVerbosities() {
return { Verbosity::Normal };
}
void noMatchingTestCases(std::string const& /*spec*/) override {}
void testRunStarting(TestRunInfo const& testRunInfo) override {
CumulativeReporterBase::testRunStarting(testRunInfo);
xml.startElement("testExecutions");
xml.writeAttribute("version", "1");
}
void testGroupEnded(TestGroupStats const& testGroupStats) override {
CumulativeReporterBase::testGroupEnded(testGroupStats);
writeGroup(*m_testGroups.back());
}
void testRunEndedCumulative() override {
xml.endElement();
}
void writeGroup(TestGroupNode const& groupNode) {
std::map<std::string, TestGroupNode::ChildNodes> testsPerFile;
for(auto const& child : groupNode.children)
testsPerFile[child->value.testInfo.lineInfo.file].push_back(child);
for(auto const& kv : testsPerFile)
writeTestFile(kv.first.c_str(), kv.second);
}
void writeTestFile(const char* filename, TestGroupNode::ChildNodes const& testCaseNodes) {
XmlWriter::ScopedElement e = xml.scopedElement("file");
xml.writeAttribute("path", filename);
for(auto const& child : testCaseNodes)
writeTestCase(*child);
}
void writeTestCase(TestCaseNode const& testCaseNode) {
// All test cases have exactly one section - which represents the
// test case itself. That section may have 0-n nested sections
assert(testCaseNode.children.size() == 1);
SectionNode const& rootSection = *testCaseNode.children.front();
writeSection("", rootSection, testCaseNode.value.testInfo.okToFail());
}
void writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail) {
std::string name = trim(sectionNode.stats.sectionInfo.name);
if(!rootName.empty())
name = rootName + '/' + name;
if(!sectionNode.assertions.empty() || !sectionNode.stdOut.empty() || !sectionNode.stdErr.empty()) {
XmlWriter::ScopedElement e = xml.scopedElement("testCase");
xml.writeAttribute("name", name);
xml.writeAttribute("duration", static_cast<long>(sectionNode.stats.durationInSeconds * 1000));
writeAssertions(sectionNode, okToFail);
}
for(auto const& childNode : sectionNode.childSections)
writeSection(name, *childNode, okToFail);
}
void writeAssertions(SectionNode const& sectionNode, bool okToFail) {
for(auto const& assertion : sectionNode.assertions)
writeAssertion( assertion, okToFail);
}
void writeAssertion(AssertionStats const& stats, bool okToFail) {
AssertionResult const& result = stats.assertionResult;
if(!result.isOk()) {
std::string elementName;
if(okToFail) {
elementName = "skipped";
}
else {
switch(result.getResultType()) {
case ResultWas::ThrewException:
case ResultWas::FatalErrorCondition:
elementName = "error";
break;
case ResultWas::ExplicitFailure:
elementName = "failure";
break;
case ResultWas::ExpressionFailed:
elementName = "failure";
break;
case ResultWas::DidntThrowException:
elementName = "failure";
break;
// We should never see these here:
case ResultWas::Info:
case ResultWas::Warning:
case ResultWas::Ok:
case ResultWas::Unknown:
case ResultWas::FailureBit:
case ResultWas::Exception:
elementName = "internalError";
break;
}
}
XmlWriter::ScopedElement e = xml.scopedElement(elementName);
ReusableStringStream messageRss;
messageRss << result.getTestMacroName() << "(" << result.getExpression() << ")";
xml.writeAttribute("message", messageRss.str());
ReusableStringStream textRss;
if (stats.totals.assertions.total() > 0) {
textRss << "FAILED:\n";
if (result.hasExpression()) {
textRss << "\t" << result.getExpressionInMacro() << "\n";
}
if (result.hasExpandedExpression()) {
textRss << "with expansion:\n\t" << result.getExpandedExpression() << "\n";
}
}
if(!result.getMessage().empty())
textRss << result.getMessage() << "\n";
for(auto const& msg : stats.infoMessages)
if(msg.type == ResultWas::Info)
textRss << msg.message << "\n";
textRss << "at " << result.getSourceInfo();
xml.writeText(textRss.str(), XmlFormatting::Newline);
}
}
private:
XmlWriter xml;
};
#ifdef CATCH_IMPL
SonarQubeReporter::~SonarQubeReporter() {}
#endif
CATCH_REGISTER_REPORTER( "sonarqube", SonarQubeReporter )
} // end namespace Catch
#endif // CATCH_REPORTER_SONARQUBE_HPP_INCLUDED

508
third_party/catch2/include/catch2/catch_reporter_tap.hpp vendored
Unescape View File

@ -1,254 +1,254 @@
/*
* Created by Colton Wolkins on 2015-08-15.
* Copyright 2015 Martin Moene. All rights reserved.
*
* Distributed under the Boost Software License, Version 1.0. (See accompanying
* file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
#define TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
// Don't #include any Catch headers here - we can assume they are already
// included before this header.
// This is not good practice in general but is necessary in this case so this
// file can be distributed as a single header that works with the main
// Catch single header.
#include <algorithm>
namespace Catch {
struct TAPReporter : StreamingReporterBase<TAPReporter> {
using StreamingReporterBase::StreamingReporterBase;
TAPReporter( ReporterConfig const& config ):
StreamingReporterBase( config ) {
m_reporterPrefs.shouldReportAllAssertions = true;
}
~TAPReporter() override;
static std::string getDescription() {
return "Reports test results in TAP format, suitable for test harnesses";
}
void noMatchingTestCases( std::string const& spec ) override {
stream << "# No test cases matched '" << spec << "'" << std::endl;
}
void assertionStarting( AssertionInfo const& ) override {}
bool assertionEnded( AssertionStats const& _assertionStats ) override {
++counter;
stream << "# " << currentTestCaseInfo->name << std::endl;
AssertionPrinter printer( stream, _assertionStats, counter );
printer.print();
stream << std::endl;
return true;
}
void testRunEnded( TestRunStats const& _testRunStats ) override {
printTotals( _testRunStats.totals );
stream << "\n" << std::endl;
StreamingReporterBase::testRunEnded( _testRunStats );
}
private:
std::size_t counter = 0;
class AssertionPrinter {
public:
AssertionPrinter& operator= ( AssertionPrinter const& ) = delete;
AssertionPrinter( AssertionPrinter const& ) = delete;
AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, std::size_t _counter )
: stream( _stream )
, result( _stats.assertionResult )
, messages( _stats.infoMessages )
, itMessage( _stats.infoMessages.begin() )
, printInfoMessages( true )
, counter(_counter)
{}
void print() {
itMessage = messages.begin();
switch( result.getResultType() ) {
case ResultWas::Ok:
printResultType( passedString() );
printOriginalExpression();
printReconstructedExpression();
if ( ! result.hasExpression() )
printRemainingMessages( Colour::None );
else
printRemainingMessages();
break;
case ResultWas::ExpressionFailed:
if (result.isOk()) {
printResultType(passedString());
} else {
printResultType(failedString());
}
printOriginalExpression();
printReconstructedExpression();
if (result.isOk()) {
printIssue(" # TODO");
}
printRemainingMessages();
break;
case ResultWas::ThrewException:
printResultType( failedString() );
printIssue( "unexpected exception with message:" );
printMessage();
printExpressionWas();
printRemainingMessages();
break;
case ResultWas::FatalErrorCondition:
printResultType( failedString() );
printIssue( "fatal error condition with message:" );
printMessage();
printExpressionWas();
printRemainingMessages();
break;
case ResultWas::DidntThrowException:
printResultType( failedString() );
printIssue( "expected exception, got none" );
printExpressionWas();
printRemainingMessages();
break;
case ResultWas::Info:
printResultType( "info" );
printMessage();
printRemainingMessages();
break;
case ResultWas::Warning:
printResultType( "warning" );
printMessage();
printRemainingMessages();
break;
case ResultWas::ExplicitFailure:
printResultType( failedString() );
printIssue( "explicitly" );
printRemainingMessages( Colour::None );
break;
// These cases are here to prevent compiler warnings
case ResultWas::Unknown:
case ResultWas::FailureBit:
case ResultWas::Exception:
printResultType( "** internal error **" );
break;
}
}
private:
static Colour::Code dimColour() { return Colour::FileName; }
static const char* failedString() { return "not ok"; }
static const char* passedString() { return "ok"; }
void printSourceInfo() const {
Colour colourGuard( dimColour() );
stream << result.getSourceInfo() << ":";
}
void printResultType( std::string const& passOrFail ) const {
if( !passOrFail.empty() ) {
stream << passOrFail << ' ' << counter << " -";
}
}
void printIssue( std::string const& issue ) const {
stream << " " << issue;
}
void printExpressionWas() {
if( result.hasExpression() ) {
stream << ";";
{
Colour colour( dimColour() );
stream << " expression was:";
}
printOriginalExpression();
}
}
void printOriginalExpression() const {
if( result.hasExpression() ) {
stream << " " << result.getExpression();
}
}
void printReconstructedExpression() const {
if( result.hasExpandedExpression() ) {
{
Colour colour( dimColour() );
stream << " for: ";
}
std::string expr = result.getExpandedExpression();
std::replace( expr.begin(), expr.end(), '\n', ' ');
stream << expr;
}
}
void printMessage() {
if ( itMessage != messages.end() ) {
stream << " '" << itMessage->message << "'";
++itMessage;
}
}
void printRemainingMessages( Colour::Code colour = dimColour() ) {
if (itMessage == messages.end()) {
return;
}
const auto itEnd = messages.cend();
const auto N = static_cast<std::size_t>( std::distance( itMessage, itEnd ) );
{
Colour colourGuard( colour );
stream << " with " << pluralise( N, "message" ) << ":";
}
while( itMessage != itEnd ) {
// If this assertion is a warning ignore any INFO messages
if( printInfoMessages || itMessage->type != ResultWas::Info ) {
stream << " '" << itMessage->message << "'";
if ( ++itMessage != itEnd ) {
Colour colourGuard( dimColour() );
stream << " and";
}
continue;
}
++itMessage;
}
}
private:
std::ostream& stream;
AssertionResult const& result;
std::vector<MessageInfo> messages;
std::vector<MessageInfo>::const_iterator itMessage;
bool printInfoMessages;
std::size_t counter;
};
void printTotals( const Totals& totals ) const {
stream << "1.." << totals.assertions.total();
if( totals.testCases.total() == 0 ) {
stream << " # Skipped: No tests ran.";
}
}
};
#ifdef CATCH_IMPL
TAPReporter::~TAPReporter() {}
#endif
CATCH_REGISTER_REPORTER( "tap", TAPReporter )
} // end namespace Catch
#endif // TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
/*
* Created by Colton Wolkins on 2015-08-15.
* Copyright 2015 Martin Moene. All rights reserved.
*
* Distributed under the Boost Software License, Version 1.0. (See accompanying
* file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
#define TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED
// Don't #include any Catch headers here - we can assume they are already
// included before this header.
// This is not good practice in general but is necessary in this case so this
// file can be distributed as a single header that works with the main
// Catch single header.
#include <algorithm>
namespace Catch {
struct TAPReporter : StreamingReporterBase<TAPReporter> {
using StreamingReporterBase::StreamingReporterBase;
TAPReporter( ReporterConfig const& config ):
StreamingReporterBase( config ) {
m_reporterPrefs.shouldReportAllAssertions = true;
}
~TAPReporter() override;
static std::string getDescription() {
return "Reports test results in TAP format, suitable for test harnesses";
}
void noMatchingTestCases( std::string const& spec ) override {
stream << "# No test cases matched '" << spec << "'" << std::endl;
}
void assertionStarting( AssertionInfo const& ) override {}
bool assertionEnded( AssertionStats const& _assertionStats ) override {
++counter;
stream << "# " << currentTestCaseInfo->name << std::endl;
AssertionPrinter printer( stream, _assertionStats, counter );
printer.print();
stream << std::endl;
return true;
}
void testRunEnded( TestRunStats const& _testRunStats ) override {
printTotals( _testRunStats.totals );
stream << "\n" << std::endl;
StreamingReporterBase::testRunEnded( _testRunStats );
}
private:
std::size_t counter = 0;
class AssertionPrinter {
public:
AssertionPrinter& operator= ( AssertionPrinter const& ) = delete;
AssertionPrinter( AssertionPrinter const& ) = delete;
AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, std::size_t _counter )
: stream( _stream )
, result( _stats.assertionResult )
, messages( _stats.infoMessages )
, itMessage( _stats.infoMessages.begin() )
, printInfoMessages( true )
, counter(_counter)
{}
void print() {
itMessage = messages.begin();
switch( result.getResultType() ) {
case ResultWas::Ok:
printResultType( passedString() );
printOriginalExpression();
printReconstructedExpression();
if ( ! result.hasExpression() )
printRemainingMessages( Colour::None );
else
printRemainingMessages();
break;
case ResultWas::ExpressionFailed:
if (result.isOk()) {
printResultType(passedString());
} else {
printResultType(failedString());
}
printOriginalExpression();
printReconstructedExpression();
if (result.isOk()) {
printIssue(" # TODO");
}
printRemainingMessages();
break;
case ResultWas::ThrewException:
printResultType( failedString() );
printIssue( "unexpected exception with message:" );
printMessage();
printExpressionWas();
printRemainingMessages();
break;
case ResultWas::FatalErrorCondition:
printResultType( failedString() );
printIssue( "fatal error condition with message:" );
printMessage();
printExpressionWas();
printRemainingMessages();
break;
case ResultWas::DidntThrowException:
printResultType( failedString() );
printIssue( "expected exception, got none" );
printExpressionWas();
printRemainingMessages();
break;
case ResultWas::Info:
printResultType( "info" );
printMessage();
printRemainingMessages();
break;
case ResultWas::Warning:
printResultType( "warning" );
printMessage();
printRemainingMessages();
break;
case ResultWas::ExplicitFailure:
printResultType( failedString() );
printIssue( "explicitly" );
printRemainingMessages( Colour::None );
break;
// These cases are here to prevent compiler warnings
case ResultWas::Unknown:
case ResultWas::FailureBit:
case ResultWas::Exception:
printResultType( "** internal error **" );
break;
}
}
private:
static Colour::Code dimColour() { return Colour::FileName; }
static const char* failedString() { return "not ok"; }
static const char* passedString() { return "ok"; }
void printSourceInfo() const {
Colour colourGuard( dimColour() );
stream << result.getSourceInfo() << ":";
}
void printResultType( std::string const& passOrFail ) const {
if( !passOrFail.empty() ) {
stream << passOrFail << ' ' << counter << " -";
}
}
void printIssue( std::string const& issue ) const {
stream << " " << issue;
}
void printExpressionWas() {
if( result.hasExpression() ) {
stream << ";";
{
Colour colour( dimColour() );
stream << " expression was:";
}
printOriginalExpression();
}
}
void printOriginalExpression() const {
if( result.hasExpression() ) {
stream << " " << result.getExpression();
}
}
void printReconstructedExpression() const {
if( result.hasExpandedExpression() ) {
{
Colour colour( dimColour() );
stream << " for: ";
}
std::string expr = result.getExpandedExpression();
std::replace( expr.begin(), expr.end(), '\n', ' ');
stream << expr;
}
}
void printMessage() {
if ( itMessage != messages.end() ) {
stream << " '" << itMessage->message << "'";
++itMessage;
}
}
void printRemainingMessages( Colour::Code colour = dimColour() ) {
if (itMessage == messages.end()) {
return;
}
const auto itEnd = messages.cend();
const auto N = static_cast<std::size_t>( std::distance( itMessage, itEnd ) );
{
Colour colourGuard( colour );
stream << " with " << pluralise( N, "message" ) << ":";
}
while( itMessage != itEnd ) {
// If this assertion is a warning ignore any INFO messages
if( printInfoMessages || itMessage->type != ResultWas::Info ) {
stream << " '" << itMessage->message << "'";
if ( ++itMessage != itEnd ) {
Colour colourGuard( dimColour() );
stream << " and";
}
continue;
}
++itMessage;
}
}
private:
std::ostream& stream;
AssertionResult const& result;
std::vector<MessageInfo> messages;
std::vector<MessageInfo>::const_iterator itMessage;
bool printInfoMessages;
std::size_t counter;
};
void printTotals( const Totals& totals ) const {
stream << "1.." << totals.assertions.total();
if( totals.testCases.total() == 0 ) {
stream << " # Skipped: No tests ran.";
}
}
};
#ifdef CATCH_IMPL
TAPReporter::~TAPReporter() {}
#endif
CATCH_REGISTER_REPORTER( "tap", TAPReporter )
} // end namespace Catch
#endif // TWOBLUECUBES_CATCH_REPORTER_TAP_HPP_INCLUDED

438
third_party/catch2/include/catch2/catch_reporter_teamcity.hpp vendored
Unescape View File

@ -1,219 +1,219 @@
/*
* Created by Phil Nash on 19th December 2014
* Copyright 2014 Two Blue Cubes Ltd. All rights reserved.
*
* Distributed under the Boost Software License, Version 1.0. (See accompanying
* file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
#define TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
// Don't #include any Catch headers here - we can assume they are already
// included before this header.
// This is not good practice in general but is necessary in this case so this
// file can be distributed as a single header that works with the main
// Catch single header.
#include <cstring>
#ifdef __clang__
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wpadded"
#endif
namespace Catch {
struct TeamCityReporter : StreamingReporterBase<TeamCityReporter> {
TeamCityReporter( ReporterConfig const& _config )
: StreamingReporterBase( _config )
{
m_reporterPrefs.shouldRedirectStdOut = true;
}
static std::string escape( std::string const& str ) {
std::string escaped = str;
replaceInPlace( escaped, "|", "||" );
replaceInPlace( escaped, "'", "|'" );
replaceInPlace( escaped, "\n", "|n" );
replaceInPlace( escaped, "\r", "|r" );
replaceInPlace( escaped, "[", "|[" );
replaceInPlace( escaped, "]", "|]" );
return escaped;
}
~TeamCityReporter() override;
static std::string getDescription() {
return "Reports test results as TeamCity service messages";
}
void skipTest( TestCaseInfo const& /* testInfo */ ) override {
}
void noMatchingTestCases( std::string const& /* spec */ ) override {}
void testGroupStarting( GroupInfo const& groupInfo ) override {
StreamingReporterBase::testGroupStarting( groupInfo );
stream << "##teamcity[testSuiteStarted name='"
<< escape( groupInfo.name ) << "']\n";
}
void testGroupEnded( TestGroupStats const& testGroupStats ) override {
StreamingReporterBase::testGroupEnded( testGroupStats );
stream << "##teamcity[testSuiteFinished name='"
<< escape( testGroupStats.groupInfo.name ) << "']\n";
}
void assertionStarting( AssertionInfo const& ) override {}
bool assertionEnded( AssertionStats const& assertionStats ) override {
AssertionResult const& result = assertionStats.assertionResult;
if( !result.isOk() ) {
ReusableStringStream msg;
if( !m_headerPrintedForThisSection )
printSectionHeader( msg.get() );
m_headerPrintedForThisSection = true;
msg << result.getSourceInfo() << "\n";
switch( result.getResultType() ) {
case ResultWas::ExpressionFailed:
msg << "expression failed";
break;
case ResultWas::ThrewException:
msg << "unexpected exception";
break;
case ResultWas::FatalErrorCondition:
msg << "fatal error condition";
break;
case ResultWas::DidntThrowException:
msg << "no exception was thrown where one was expected";
break;
case ResultWas::ExplicitFailure:
msg << "explicit failure";
break;
// We shouldn't get here because of the isOk() test
case ResultWas::Ok:
case ResultWas::Info:
case ResultWas::Warning:
CATCH_ERROR( "Internal error in TeamCity reporter" );
// These cases are here to prevent compiler warnings
case ResultWas::Unknown:
case ResultWas::FailureBit:
case ResultWas::Exception:
CATCH_ERROR( "Not implemented" );
}
if( assertionStats.infoMessages.size() == 1 )
msg << " with message:";
if( assertionStats.infoMessages.size() > 1 )
msg << " with messages:";
for( auto const& messageInfo : assertionStats.infoMessages )
msg << "\n \"" << messageInfo.message << "\"";
if( result.hasExpression() ) {
msg <<
"\n " << result.getExpressionInMacro() << "\n"
"with expansion:\n" <<
" " << result.getExpandedExpression() << "\n";
}
if( currentTestCaseInfo->okToFail() ) {
msg << "- failure ignore as test marked as 'ok to fail'\n";
stream << "##teamcity[testIgnored"
<< " name='" << escape( currentTestCaseInfo->name )<< "'"
<< " message='" << escape( msg.str() ) << "'"
<< "]\n";
}
else {
stream << "##teamcity[testFailed"
<< " name='" << escape( currentTestCaseInfo->name )<< "'"
<< " message='" << escape( msg.str() ) << "'"
<< "]\n";
}
}
stream.flush();
return true;
}
void sectionStarting( SectionInfo const& sectionInfo ) override {
m_headerPrintedForThisSection = false;
StreamingReporterBase::sectionStarting( sectionInfo );
}
void testCaseStarting( TestCaseInfo const& testInfo ) override {
m_testTimer.start();
StreamingReporterBase::testCaseStarting( testInfo );
stream << "##teamcity[testStarted name='"
<< escape( testInfo.name ) << "']\n";
stream.flush();
}
void testCaseEnded( TestCaseStats const& testCaseStats ) override {
StreamingReporterBase::testCaseEnded( testCaseStats );
if( !testCaseStats.stdOut.empty() )
stream << "##teamcity[testStdOut name='"
<< escape( testCaseStats.testInfo.name )
<< "' out='" << escape( testCaseStats.stdOut ) << "']\n";
if( !testCaseStats.stdErr.empty() )
stream << "##teamcity[testStdErr name='"
<< escape( testCaseStats.testInfo.name )
<< "' out='" << escape( testCaseStats.stdErr ) << "']\n";
stream << "##teamcity[testFinished name='"
<< escape( testCaseStats.testInfo.name ) << "' duration='"
<< m_testTimer.getElapsedMilliseconds() << "']\n";
stream.flush();
}
private:
void printSectionHeader( std::ostream& os ) {
assert( !m_sectionStack.empty() );
if( m_sectionStack.size() > 1 ) {
os << getLineOfChars<'-'>() << "\n";
std::vector<SectionInfo>::const_iterator
it = m_sectionStack.begin()+1, // Skip first section (test case)
itEnd = m_sectionStack.end();
for( ; it != itEnd; ++it )
printHeaderString( os, it->name );
os << getLineOfChars<'-'>() << "\n";
}
SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
os << lineInfo << "\n";
os << getLineOfChars<'.'>() << "\n\n";
}
// if string has a : in first line will set indent to follow it on
// subsequent lines
static void printHeaderString( std::ostream& os, std::string const& _string, std::size_t indent = 0 ) {
std::size_t i = _string.find( ": " );
if( i != std::string::npos )
i+=2;
else
i = 0;
os << Column( _string )
.indent( indent+i)
.initialIndent( indent ) << "\n";
}
private:
bool m_headerPrintedForThisSection = false;
Timer m_testTimer;
};
#ifdef CATCH_IMPL
TeamCityReporter::~TeamCityReporter() {}
#endif
CATCH_REGISTER_REPORTER( "teamcity", TeamCityReporter )
} // end namespace Catch
#ifdef __clang__
# pragma clang diagnostic pop
#endif
#endif // TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
/*
* Created by Phil Nash on 19th December 2014
* Copyright 2014 Two Blue Cubes Ltd. All rights reserved.
*
* Distributed under the Boost Software License, Version 1.0. (See accompanying
* file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
#define TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
// Don't #include any Catch headers here - we can assume they are already
// included before this header.
// This is not good practice in general but is necessary in this case so this
// file can be distributed as a single header that works with the main
// Catch single header.
#include <cstring>
#ifdef __clang__
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wpadded"
#endif
namespace Catch {
struct TeamCityReporter : StreamingReporterBase<TeamCityReporter> {
TeamCityReporter( ReporterConfig const& _config )
: StreamingReporterBase( _config )
{
m_reporterPrefs.shouldRedirectStdOut = true;
}
static std::string escape( std::string const& str ) {
std::string escaped = str;
replaceInPlace( escaped, "|", "||" );
replaceInPlace( escaped, "'", "|'" );
replaceInPlace( escaped, "\n", "|n" );
replaceInPlace( escaped, "\r", "|r" );
replaceInPlace( escaped, "[", "|[" );
replaceInPlace( escaped, "]", "|]" );
return escaped;
}
~TeamCityReporter() override;
static std::string getDescription() {
return "Reports test results as TeamCity service messages";
}
void skipTest( TestCaseInfo const& /* testInfo */ ) override {
}
void noMatchingTestCases( std::string const& /* spec */ ) override {}
void testGroupStarting( GroupInfo const& groupInfo ) override {
StreamingReporterBase::testGroupStarting( groupInfo );
stream << "##teamcity[testSuiteStarted name='"
<< escape( groupInfo.name ) << "']\n";
}
void testGroupEnded( TestGroupStats const& testGroupStats ) override {
StreamingReporterBase::testGroupEnded( testGroupStats );
stream << "##teamcity[testSuiteFinished name='"
<< escape( testGroupStats.groupInfo.name ) << "']\n";
}
void assertionStarting( AssertionInfo const& ) override {}
bool assertionEnded( AssertionStats const& assertionStats ) override {
AssertionResult const& result = assertionStats.assertionResult;
if( !result.isOk() ) {
ReusableStringStream msg;
if( !m_headerPrintedForThisSection )
printSectionHeader( msg.get() );
m_headerPrintedForThisSection = true;
msg << result.getSourceInfo() << "\n";
switch( result.getResultType() ) {
case ResultWas::ExpressionFailed:
msg << "expression failed";
break;
case ResultWas::ThrewException:
msg << "unexpected exception";
break;
case ResultWas::FatalErrorCondition:
msg << "fatal error condition";
break;
case ResultWas::DidntThrowException:
msg << "no exception was thrown where one was expected";
break;
case ResultWas::ExplicitFailure:
msg << "explicit failure";
break;
// We shouldn't get here because of the isOk() test
case ResultWas::Ok:
case ResultWas::Info:
case ResultWas::Warning:
CATCH_ERROR( "Internal error in TeamCity reporter" );
// These cases are here to prevent compiler warnings
case ResultWas::Unknown:
case ResultWas::FailureBit:
case ResultWas::Exception:
CATCH_ERROR( "Not implemented" );
}
if( assertionStats.infoMessages.size() == 1 )
msg << " with message:";
if( assertionStats.infoMessages.size() > 1 )
msg << " with messages:";
for( auto const& messageInfo : assertionStats.infoMessages )
msg << "\n \"" << messageInfo.message << "\"";
if( result.hasExpression() ) {
msg <<
"\n " << result.getExpressionInMacro() << "\n"
"with expansion:\n" <<
" " << result.getExpandedExpression() << "\n";
}
if( currentTestCaseInfo->okToFail() ) {
msg << "- failure ignore as test marked as 'ok to fail'\n";
stream << "##teamcity[testIgnored"
<< " name='" << escape( currentTestCaseInfo->name )<< "'"
<< " message='" << escape( msg.str() ) << "'"
<< "]\n";
}
else {
stream << "##teamcity[testFailed"
<< " name='" << escape( currentTestCaseInfo->name )<< "'"
<< " message='" << escape( msg.str() ) << "'"
<< "]\n";
}
}
stream.flush();
return true;
}
void sectionStarting( SectionInfo const& sectionInfo ) override {
m_headerPrintedForThisSection = false;
StreamingReporterBase::sectionStarting( sectionInfo );
}
void testCaseStarting( TestCaseInfo const& testInfo ) override {
m_testTimer.start();
StreamingReporterBase::testCaseStarting( testInfo );
stream << "##teamcity[testStarted name='"
<< escape( testInfo.name ) << "']\n";
stream.flush();
}
void testCaseEnded( TestCaseStats const& testCaseStats ) override {
StreamingReporterBase::testCaseEnded( testCaseStats );
if( !testCaseStats.stdOut.empty() )
stream << "##teamcity[testStdOut name='"
<< escape( testCaseStats.testInfo.name )
<< "' out='" << escape( testCaseStats.stdOut ) << "']\n";
if( !testCaseStats.stdErr.empty() )
stream << "##teamcity[testStdErr name='"
<< escape( testCaseStats.testInfo.name )
<< "' out='" << escape( testCaseStats.stdErr ) << "']\n";
stream << "##teamcity[testFinished name='"
<< escape( testCaseStats.testInfo.name ) << "' duration='"
<< m_testTimer.getElapsedMilliseconds() << "']\n";
stream.flush();
}
private:
void printSectionHeader( std::ostream& os ) {
assert( !m_sectionStack.empty() );
if( m_sectionStack.size() > 1 ) {
os << getLineOfChars<'-'>() << "\n";
std::vector<SectionInfo>::const_iterator
it = m_sectionStack.begin()+1, // Skip first section (test case)
itEnd = m_sectionStack.end();
for( ; it != itEnd; ++it )
printHeaderString( os, it->name );
os << getLineOfChars<'-'>() << "\n";
}
SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
os << lineInfo << "\n";
os << getLineOfChars<'.'>() << "\n\n";
}
// if string has a : in first line will set indent to follow it on
// subsequent lines
static void printHeaderString( std::ostream& os, std::string const& _string, std::size_t indent = 0 ) {
std::size_t i = _string.find( ": " );
if( i != std::string::npos )
i+=2;
else
i = 0;
os << Column( _string )
.indent( indent+i)
.initialIndent( indent ) << "\n";
}
private:
bool m_headerPrintedForThisSection = false;
Timer m_testTimer;
};
#ifdef CATCH_IMPL
TeamCityReporter::~TeamCityReporter() {}
#endif
CATCH_REGISTER_REPORTER( "teamcity", TeamCityReporter )
} // end namespace Catch
#ifdef __clang__
# pragma clang diagnostic pop
#endif
#endif // TWOBLUECUBES_CATCH_REPORTER_TEAMCITY_HPP_INCLUDED

254
third_party/snpe/include/DlSystem/IOBufferDataTypeMap.hpp vendored
Unescape View File

@ -1,127 +1,127 @@
//=============================================================================
//
// Copyright (c) 2021-2022 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
//
//=============================================================================
#ifndef DL_SYSTEM_IOBUFFER_DATATYPE_MAP_HPP
#define DL_SYSTEM_IOBUFFER_DATATYPE_MAP_HPP
#include <cstddef>
#include <memory>
#include "DlSystem/DlEnums.hpp"
namespace DlSystem
{
// Forward declaration of IOBufferDataTypeMapImpl implementation.
class IOBufferDataTypeMapImpl;
}
namespace zdl
{
namespace DlSystem
{
/** @addtogroup c_plus_plus_apis C++
@{ */
/**
* @brief .
*
* The IoBufferDataTypeMap class definition
*/
class ZDL_EXPORT IOBufferDataTypeMap final
{
public:
/**
* @brief .
*
* Creates a new Buffer Data type map
*
*/
IOBufferDataTypeMap();
/**
* @brief Adds a name and the corresponding buffer data type
* to the map
*
* @param[name] name The name of the buffer
* @param[bufferDataType] buffer Data Type of the buffer
*
* @note If a buffer with the same name already exists, no new
* buffer is added.
*/
void add(const char* name, zdl::DlSystem::IOBufferDataType_t bufferDataType);
/**
* @brief Removes a buffer name from the map
*
* @param[name] name The name of the buffer
*
*/
void remove(const char* name);
/**
* @brief Returns the type of the named buffer
*
* @param[name] name The name of the buffer
*
* @return The type of the buffer, or UNSPECIFIED if the buffer does not exist
*
*/
zdl::DlSystem::IOBufferDataType_t getBufferDataType(const char* name);
/**
* @brief Returns the type of the first buffer
*
* @return The type of the first buffer, or UNSPECIFIED if the map is empty.
*
*/
zdl::DlSystem::IOBufferDataType_t getBufferDataType();
/**
* @brief Returns the size of the buffer type map.
*
* @return The size of the map
*
*/
size_t size();
/**
* @brief Checks the existence of the named buffer in the map
*
* @return True if the named buffer exists, false otherwise.
*
*/
bool find(const char* name);
/**
* @brief Resets the map
*
*/
void clear();
/**
* @brief Checks whether the map is empty
*
* @return True if the map is empty, false otherwise.
*
*/
bool empty();
/**
* @brief Destroys the map
*
*/
~IOBufferDataTypeMap();
private:
std::shared_ptr<::DlSystem::IOBufferDataTypeMapImpl> m_IOBufferDataTypeMapImpl;
};
}
}
#endif
//=============================================================================
//
// Copyright (c) 2021-2022 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
//
//=============================================================================
#ifndef DL_SYSTEM_IOBUFFER_DATATYPE_MAP_HPP
#define DL_SYSTEM_IOBUFFER_DATATYPE_MAP_HPP
#include <cstddef>
#include <memory>
#include "DlSystem/DlEnums.hpp"
namespace DlSystem
{
// Forward declaration of IOBufferDataTypeMapImpl implementation.
class IOBufferDataTypeMapImpl;
}
namespace zdl
{
namespace DlSystem
{
/** @addtogroup c_plus_plus_apis C++
@{ */
/**
* @brief .
*
* The IoBufferDataTypeMap class definition
*/
class ZDL_EXPORT IOBufferDataTypeMap final
{
public:
/**
* @brief .
*
* Creates a new Buffer Data type map
*
*/
IOBufferDataTypeMap();
/**
* @brief Adds a name and the corresponding buffer data type
* to the map
*
* @param[name] name The name of the buffer
* @param[bufferDataType] buffer Data Type of the buffer
*
* @note If a buffer with the same name already exists, no new
* buffer is added.
*/
void add(const char* name, zdl::DlSystem::IOBufferDataType_t bufferDataType);
/**
* @brief Removes a buffer name from the map
*
* @param[name] name The name of the buffer
*
*/
void remove(const char* name);
/**
* @brief Returns the type of the named buffer
*
* @param[name] name The name of the buffer
*
* @return The type of the buffer, or UNSPECIFIED if the buffer does not exist
*
*/
zdl::DlSystem::IOBufferDataType_t getBufferDataType(const char* name);
/**
* @brief Returns the type of the first buffer
*
* @return The type of the first buffer, or UNSPECIFIED if the map is empty.
*
*/
zdl::DlSystem::IOBufferDataType_t getBufferDataType();
/**
* @brief Returns the size of the buffer type map.
*
* @return The size of the map
*
*/
size_t size();
/**
* @brief Checks the existence of the named buffer in the map
*
* @return True if the named buffer exists, false otherwise.
*
*/
bool find(const char* name);
/**
* @brief Resets the map
*
*/
void clear();
/**
* @brief Checks whether the map is empty
*
* @return True if the map is empty, false otherwise.
*
*/
bool empty();
/**
* @brief Destroys the map
*
*/
~IOBufferDataTypeMap();
private:
std::shared_ptr<::DlSystem::IOBufferDataTypeMapImpl> m_IOBufferDataTypeMapImpl;
};
}
}
#endif

Write Preview
Loading…
Cancel
Save