sparseGaussianTest< Scalar > Struct Template Reference

Inheritance diagram for sparseGaussianTest< Scalar >:

Public Types
typedef Matrix< Scalar, Dynamic, 1 >	VectorType
typedef SparseFunctor< Scalar, int >	Base
typedef Base::JacobianType	JacobianType
Public Types inherited from Eigen::SparseFunctor< Scalar, int >
enum
typedef Scalar	Scalar
typedef int	Index
typedef Matrix< Scalar, Dynamic, 1 >	InputType
typedef Matrix< Scalar, Dynamic, 1 >	ValueType
typedef SparseMatrix< Scalar, ColMajor, Index >	JacobianType
typedef SparseQR< JacobianType, COLAMDOrdering< int > >	QRSolver

Public Member Functions
	sparseGaussianTest (int inputs, int values)
VectorType	model (const VectorType &uv, VectorType &x)
void	initPoints (VectorType &uv_ref, VectorType &x)
int	operator() (const VectorType &uv, VectorType &fvec)
int	df (const VectorType &uv, JacobianType &fjac)
Public Member Functions inherited from Eigen::SparseFunctor< Scalar, int >
	SparseFunctor (int inputs, int values)
int	inputs () const
int	values () const

Public Attributes
VectorType	m_x
VectorType	m_y
Public Attributes inherited from Eigen::SparseFunctor< Scalar, int >
const int	m_inputs
const int	m_values

Member Typedef Documentation

Base

template<typename Scalar >

typedef SparseFunctor<Scalar, int> sparseGaussianTest< Scalar >::Base

JacobianType

template<typename Scalar >

typedef Base::JacobianType sparseGaussianTest< Scalar >::JacobianType

VectorType

template<typename Scalar >

typedef Matrix<Scalar, Dynamic, 1> sparseGaussianTest< Scalar >::VectorType

Constructor & Destructor Documentation

sparseGaussianTest()

template<typename Scalar >

sparseGaussianTest< Scalar >::sparseGaussianTest ( int  inputs, int  values  )

inline

: SparseFunctor<Scalar, int>(inputs, values) {}

Member Function Documentation

df()

template<typename Scalar >

int sparseGaussianTest< Scalar >::df ( const VectorType &  uv, JacobianType &  fjac  )

inline

                                                   {
    int m = Base::values();
    int n = Base::inputs();
    eigen_assert(n == uv.size());
    eigen_assert(fjac.rows() == m);
    eigen_assert(fjac.cols() == n);
    int half = n / 2;
    VectorBlock<const VectorType> u(uv, 0, half);
    VectorBlock<const VectorType> v(uv, half, half);
    Scalar coeff;
 
    // Derivatives with respect to u
    for (int col = 0; col < half; col++) {
      for (int row = 0; row < m; row++) {
        coeff = (m_x(row) - col) / v(col);
        coeff = coeff * coeff;
        if (coeff < 1. && coeff > 0.) {
          fjac.coeffRef(row, col) = -(1 - coeff) * (1 - coeff);
        }
      }
    }
    // Derivatives with respect to v
    for (int col = 0; col < half; col++) {
      for (int row = 0; row < m; row++) {
        coeff = (m_x(row) - col) / v(col);
        coeff = coeff * coeff;
        if (coeff < 1. && coeff > 0.) {
          fjac.coeffRef(row, col + half) = -4 * (u(col) / v(col)) * coeff * (1 - coeff);
        }
      }
    }
    return 0;
  }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::coeffRef(), col(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::cols(), eigen_assert, m, n, row(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::rows(), and v.

initPoints()

template<typename Scalar >

void sparseGaussianTest< Scalar >::initPoints ( VectorType &  uv_ref, VectorType &  x  )

inline

                                                     {
    m_x = x;
    m_y = this->model(uv_ref, x);
  }

References plotDoE::x.

Referenced by test_sparseLM_T().

model()

template<typename Scalar >

VectorType sparseGaussianTest< Scalar >::model ( const VectorType &  uv, VectorType &  x  )

inline

                                                        {
    VectorType y;  // Change this to use expression template
    int m = Base::values();
    int n = Base::inputs();
    eigen_assert(uv.size() % 2 == 0);
    eigen_assert(uv.size() == n);
    eigen_assert(x.size() == m);
    y.setZero(m);
    int half = n / 2;
    VectorBlock<const VectorType> u(uv, 0, half);
    VectorBlock<const VectorType> v(uv, half, half);
    Scalar coeff;
    for (int j = 0; j < m; j++) {
      for (int i = 0; i < half; i++) {
        coeff = (x(j) - i) / v(i);
        coeff *= coeff;
        if (coeff < 1. && coeff > 0.) y(j) += u(i) * std::pow((1 - coeff), 2);
      }
    }
    return y;
  }

References eigen_assert, i, j, m, n, Eigen::bfloat16_impl::pow(), v, plotDoE::x, and y.

operator()()

template<typename Scalar >

int sparseGaussianTest< Scalar >::operator() ( const VectorType &  uv, VectorType &  fvec  )

inline

                                                         {
    int m = Base::values();
    int n = Base::inputs();
    eigen_assert(uv.size() % 2 == 0);
    eigen_assert(uv.size() == n);
    int half = n / 2;
    VectorBlock<const VectorType> u(uv, 0, half);
    VectorBlock<const VectorType> v(uv, half, half);
    fvec = m_y;
    Scalar coeff;
    for (int j = 0; j < m; j++) {
      for (int i = 0; i < half; i++) {
        coeff = (m_x(j) - i) / v(i);
        coeff *= coeff;
        if (coeff < 1. && coeff > 0.) fvec(j) -= u(i) * std::pow((1 - coeff), 2);
      }
    }
    return 0;
  }

References eigen_assert, i, j, m, n, Eigen::bfloat16_impl::pow(), and v.

Member Data Documentation

m_x

template<typename Scalar >

VectorType sparseGaussianTest< Scalar >::m_x

m_y

template<typename Scalar >

VectorType sparseGaussianTest< Scalar >::m_y

---

The documentation for this struct was generated from the following file:

• sparseLM.cpp