mirror of
https://gitcode.com/gh_mirrors/ope/OpenFace.git
synced 2026-05-14 19:27:56 +00:00
311 lines
8.9 KiB
C++
311 lines
8.9 KiB
C++
// Copyright (C) 2010 Davis E. King (davis@dlib.net)
|
|
// License: Boost Software License See LICENSE.txt for the full license.
|
|
#ifndef DLIB_OPTIMIZATION_TEST_FUNCTiONS_H_h_
|
|
#define DLIB_OPTIMIZATION_TEST_FUNCTiONS_H_h_
|
|
|
|
#include <dlib/matrix.h>
|
|
#include <sstream>
|
|
#include <cmath>
|
|
|
|
/*
|
|
|
|
Most of the code in this file is converted from the set of Fortran 90 routines
|
|
created by John Burkardt.
|
|
|
|
The original Fortran can be found here: http://orion.math.iastate.edu/burkardt/f_src/testopt/testopt.html
|
|
|
|
*/
|
|
|
|
// GCC 4.8 gives false alarms about some variables being uninitialized. Disable these
|
|
// false warnings.
|
|
#if ( defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 8)
|
|
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
|
|
#endif
|
|
|
|
|
|
namespace dlib
|
|
{
|
|
namespace test_functions
|
|
{
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
matrix<double,0,1> chebyquad_residuals(const matrix<double,0,1>& x);
|
|
|
|
double chebyquad_residual(int i, const matrix<double,0,1>& x);
|
|
|
|
int& chebyquad_calls();
|
|
|
|
double chebyquad(const matrix<double,0,1>& x );
|
|
|
|
matrix<double,0,1> chebyquad_derivative (const matrix<double,0,1>& x);
|
|
|
|
matrix<double,0,1> chebyquad_start (int n);
|
|
|
|
matrix<double,0,1> chebyquad_solution (int n);
|
|
|
|
matrix<double> chebyquad_hessian(const matrix<double,0,1>& x);
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
class chebyquad_function_model
|
|
{
|
|
public:
|
|
|
|
// Define the type used to represent column vectors
|
|
typedef matrix<double,0,1> column_vector;
|
|
// Define the type used to represent the hessian matrix
|
|
typedef matrix<double> general_matrix;
|
|
|
|
double operator() (
|
|
const column_vector& x
|
|
) const
|
|
{
|
|
return chebyquad(x);
|
|
}
|
|
|
|
void get_derivative_and_hessian (
|
|
const column_vector& x,
|
|
column_vector& d,
|
|
general_matrix& h
|
|
) const
|
|
{
|
|
d = chebyquad_derivative(x);
|
|
h = chebyquad_hessian(x);
|
|
}
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
double brown_residual (int i, const matrix<double,4,1>& x);
|
|
/*!
|
|
requires
|
|
- 1 <= i <= 20
|
|
ensures
|
|
- returns the ith brown residual
|
|
!*/
|
|
|
|
double brown ( const matrix<double,4,1>& x);
|
|
|
|
matrix<double,4,1> brown_derivative ( const matrix<double,4,1>& x);
|
|
|
|
matrix<double,4,4> brown_hessian ( const matrix<double,4,1>& x);
|
|
|
|
matrix<double,4,1> brown_start ();
|
|
|
|
matrix<double,4,1> brown_solution ();
|
|
|
|
class brown_function_model
|
|
{
|
|
public:
|
|
|
|
// Define the type used to represent column vectors
|
|
typedef matrix<double,4,1> column_vector;
|
|
// Define the type used to represent the hessian matrix
|
|
typedef matrix<double> general_matrix;
|
|
|
|
double operator() (
|
|
const column_vector& x
|
|
) const
|
|
{
|
|
return brown(x);
|
|
}
|
|
|
|
void get_derivative_and_hessian (
|
|
const column_vector& x,
|
|
column_vector& d,
|
|
general_matrix& h
|
|
) const
|
|
{
|
|
d = brown_derivative(x);
|
|
h = brown_hessian(x);
|
|
}
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <typename T>
|
|
matrix<T,2,1> rosen_big_start()
|
|
{
|
|
matrix<T,2,1> x;
|
|
x = -1.2, -1;
|
|
return x;
|
|
}
|
|
|
|
// This is a variation on the Rosenbrock test function but with large residuals. The
|
|
// minimum is at 1, 1 and the objective value is 1.
|
|
template <typename T>
|
|
T rosen_big_residual (int i, const matrix<T,2,1>& m)
|
|
{
|
|
using std::pow;
|
|
const T x = m(0);
|
|
const T y = m(1);
|
|
|
|
if (i == 1)
|
|
{
|
|
return 100*pow(y - x*x,2)+1.0;
|
|
}
|
|
else
|
|
{
|
|
return pow(1 - x,2) + 1.0;
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
T rosen_big ( const matrix<T,2,1>& m)
|
|
{
|
|
using std::pow;
|
|
return 0.5*(pow(rosen_big_residual(1,m),2) + pow(rosen_big_residual(2,m),2));
|
|
}
|
|
|
|
template <typename T>
|
|
matrix<T,2,1> rosen_big_solution ()
|
|
{
|
|
matrix<T,2,1> x;
|
|
// solution from original documentation.
|
|
x = 1,1;
|
|
return x;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <typename T>
|
|
matrix<T,2,1> rosen_start()
|
|
{
|
|
matrix<T,2,1> x;
|
|
x = -1.2, -1;
|
|
return x;
|
|
}
|
|
|
|
template <typename T>
|
|
T rosen ( const matrix<T,2,1>& m)
|
|
{
|
|
const T x = m(0);
|
|
const T y = m(1);
|
|
|
|
using std::pow;
|
|
// compute Rosenbrock's function and return the result
|
|
return 100.0*pow(y - x*x,2) + pow(1 - x,2);
|
|
}
|
|
|
|
template <typename T>
|
|
T rosen_residual (int i, const matrix<T,2,1>& m)
|
|
{
|
|
const T x = m(0);
|
|
const T y = m(1);
|
|
|
|
|
|
if (i == 1)
|
|
{
|
|
return 10*(y - x*x);
|
|
}
|
|
else
|
|
{
|
|
return 1 - x;
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
matrix<T,2,1> rosen_residual_derivative (int i, const matrix<T,2,1>& m)
|
|
{
|
|
const T x = m(0);
|
|
|
|
matrix<T,2,1> d;
|
|
|
|
if (i == 1)
|
|
{
|
|
d = -20*x, 10;
|
|
}
|
|
else
|
|
{
|
|
d = -1, 0;
|
|
}
|
|
return d;
|
|
}
|
|
|
|
template <typename T>
|
|
const matrix<T,2,1> rosen_derivative ( const matrix<T,2,1>& m)
|
|
{
|
|
const T x = m(0);
|
|
const T y = m(1);
|
|
|
|
// make us a column vector of length 2
|
|
matrix<T,2,1> res(2);
|
|
|
|
// now compute the gradient vector
|
|
res(0) = -400*x*(y-x*x) - 2*(1-x); // derivative of rosen() with respect to x
|
|
res(1) = 200*(y-x*x); // derivative of rosen() with respect to y
|
|
return res;
|
|
}
|
|
|
|
template <typename T>
|
|
const matrix<T,2,2> rosen_hessian ( const matrix<T,2,1>& m)
|
|
{
|
|
const T x = m(0);
|
|
const T y = m(1);
|
|
|
|
// make us a column vector of length 2
|
|
matrix<T,2,2> res;
|
|
|
|
// now compute the gradient vector
|
|
res(0,0) = -400*y + 3*400*x*x + 2;
|
|
res(1,1) = 200;
|
|
|
|
res(0,1) = -400*x;
|
|
res(1,0) = -400*x;
|
|
return res;
|
|
}
|
|
|
|
template <typename T>
|
|
matrix<T,2,1> rosen_solution ()
|
|
{
|
|
matrix<T,2,1> x;
|
|
// solution from original documentation.
|
|
x = 1,1;
|
|
return x;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------
|
|
|
|
template <typename T>
|
|
struct rosen_function_model
|
|
{
|
|
typedef matrix<T,2,1> column_vector;
|
|
typedef matrix<T,2,2> general_matrix;
|
|
|
|
T operator() ( column_vector x) const
|
|
{
|
|
return static_cast<T>(rosen(x));
|
|
}
|
|
|
|
void get_derivative_and_hessian (
|
|
const column_vector& x,
|
|
column_vector& d,
|
|
general_matrix& h
|
|
) const
|
|
{
|
|
d = rosen_derivative(x);
|
|
h = rosen_hessian(x);
|
|
}
|
|
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
}
|
|
}
|
|
|
|
#endif // DLIB_OPTIMIZATION_TEST_FUNCTiONS_H_h_
|
|
|
|
|
|
|