Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	include/crocoddyl/core/activations/quadratic-flat-log.hpp	Lines:	27	34	79.4 %
Date:	2024-02-13 11:12:33	Branches:	15	72	20.8 %


///////////////////////////////////////////////////////////////////////////////
// BSD 3-Clause License
//
// Copyright (C) 2020, LAAS-CNRS, University of Edinburgh
// Copyright note valid unless otherwise stated in individual files.
// All rights reserved.
///////////////////////////////////////////////////////////////////////////////

#ifndef CROCODDYL_CORE_ACTIVATIONS_QUADRATIC_FLAT_LOG_HPP_
#define CROCODDYL_CORE_ACTIVATIONS_QUADRATIC_FLAT_LOG_HPP_

#include "crocoddyl/core/activation-base.hpp"
#include "crocoddyl/core/fwd.hpp"
#include "crocoddyl/core/utils/exception.hpp"

namespace crocoddyl {

/**
 * @brief Quadratic-flat-log activation
 *
 * This activation function describes a logarithmic quadratic activation
 * depending on the quadratic norm of a residual vector, i.e. \f[
 * \begin{equation} log(1 + \|\mathbf{r}\|^2 / \alpha) \end{equation} \f] where
 * \f$\alpha\f$ defines the width of the quadratic basin, \f$r\f$ is the scalar
 * residual, \f$nr\f$ is the dimension of the residual vector.
 *
 * The computation of the function and it derivatives are carried out in
 * `calc()` and `caldDiff()`, respectively.
 *
 * \sa `calc()`, `calcDiff()`, `createData()`
 */
template <typename _Scalar>
class ActivationModelQuadFlatLogTpl
    : public ActivationModelAbstractTpl<_Scalar> {
 public:
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW

  typedef _Scalar Scalar;
  typedef MathBaseTpl<Scalar> MathBase;
  typedef ActivationModelAbstractTpl<Scalar> Base;
  typedef ActivationDataAbstractTpl<Scalar> ActivationDataAbstract;
  typedef ActivationDataQuadFlatLogTpl<Scalar> Data;
  typedef typename MathBase::VectorXs VectorXs;
  typedef typename MathBase::MatrixXs MatrixXs;

  /*
   * @brief Initialize the quadratic-flat-log activation model
   *
   * The default `alpha` value is defined as 1.
   *
   * @param[in] nr   Dimension of the residual vector
   * @param[in] alpha  Width of quadratic basin (default: 1.)
   */

  explicit ActivationModelQuadFlatLogTpl(const std::size_t &nr,
                                         const Scalar &alpha = Scalar(1.))
      : Base(nr), alpha_(alpha) {
    if (alpha < Scalar(0.)) {
      throw_pretty("Invalid argument: "
                   << "alpha should be a positive value");
    }
  };
  virtual ~ActivationModelQuadFlatLogTpl(){};

  /*
   * @brief Compute the quadratic-flat-log function
   *
   * @param[in] data  Quadratic-log activation data
   * @param[in] r     Residual vector \f$\mathbf{r}\in\mathbb{R}^{nr}\f$
   */
  virtual void calc(const boost::shared_ptr<ActivationDataAbstract> &data,
                    const Eigen::Ref<const VectorXs> &r) {
    if (static_cast<std::size_t>(r.size()) != nr_) {
      throw_pretty("Invalid argument: "
                   << "r has wrong dimension (it should be " +
                          std::to_string(nr_) + ")");
    }
    boost::shared_ptr<Data> d = boost::static_pointer_cast<Data>(data);
    d->a0 = r.squaredNorm() / alpha_;
    data->a_value = log(Scalar(1.0) + d->a0);
  };

  /*
   * @brief Compute the derivatives of the quadratic-flat-log function
   *
   * @param[in] data  Quadratic-log activation data
   * @param[in] r     Residual vector \f$\mathbf{r}\in\mathbb{R}^{nr}\f$
   */
  virtual void calcDiff(const boost::shared_ptr<ActivationDataAbstract> &data,
                        const Eigen::Ref<const VectorXs> &r) {
    if (static_cast<std::size_t>(r.size()) != nr_) {
      throw_pretty("Invalid argument: "
                   << "r has wrong dimension (it should be " +
                          std::to_string(nr_) + ")");
    }
    boost::shared_ptr<Data> d = boost::static_pointer_cast<Data>(data);

    d->a1 = Scalar(2.0) / (alpha_ + alpha_ * d->a0);
    data->Ar = d->a1 * r;
    data->Arr.diagonal() = -d->a1 * d->a1 * r.array().square();
    data->Arr.diagonal().array() += d->a1;
  };

  /*
   * @brief Create the quadratic-flat-log activation data
   *
   * @return the activation data
   */
  virtual boost::shared_ptr<ActivationDataAbstract> createData() {
    boost::shared_ptr<Data> data =
        boost::allocate_shared<Data>(Eigen::aligned_allocator<Data>(), this);
    return data;
  };

  Scalar get_alpha() const { return alpha_; };
  void set_alpha(const Scalar alpha) { alpha_ = alpha; };

  /**
   * @brief Print relevant information of the quadratic flat-log model
   *
   * @param[out] os  Output stream object
   */
  virtual void print(std::ostream &os) const {
    os << "ActivationModelQuadFlatLog {nr=" << nr_ << ", a=" << alpha_ << "}";
  }

 protected:
  using Base::nr_;  //!< Dimension of the residual vector

 private:
  Scalar alpha_;  //!< Width of quadratic basin
};

/*
 * @brief Data structure of the quadratic-flat-log activation
 *
 * @param[in] a0  computed in calc to avoid recomputation
 * @param[in] a1  computed in calcDiff to avoid recomputation
 */
template <typename _Scalar>
struct ActivationDataQuadFlatLogTpl
    : public ActivationDataAbstractTpl<_Scalar> {
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW

  typedef _Scalar Scalar;
  typedef MathBaseTpl<Scalar> MathBase;
  typedef ActivationDataAbstractTpl<Scalar> Base;

  template <typename Activation>
  explicit ActivationDataQuadFlatLogTpl(Activation *const activation)
      : Base(activation), a0(0), a1(0) {}

  Scalar a0;
  Scalar a1;
};

}  // namespace crocoddyl

#endif  // CROCODDYL_CORE_ACTIVATIONS_QUADRATIC_FLAT_LOG_HPP_


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			///////////////////////////////////////////////////////////////////////////////
2			// BSD 3-Clause License
3			//
4			// Copyright (C) 2020, LAAS-CNRS, University of Edinburgh
5			// Copyright note valid unless otherwise stated in individual files.
6			// All rights reserved.
7			///////////////////////////////////////////////////////////////////////////////
8
9			#ifndef CROCODDYL_CORE_ACTIVATIONS_QUADRATIC_FLAT_LOG_HPP_
10			#define CROCODDYL_CORE_ACTIVATIONS_QUADRATIC_FLAT_LOG_HPP_
11
12			#include "crocoddyl/core/activation-base.hpp"
13			#include "crocoddyl/core/fwd.hpp"
14			#include "crocoddyl/core/utils/exception.hpp"
15
16			namespace crocoddyl {
17
18			/**
19			* @brief Quadratic-flat-log activation
20			*
21			* This activation function describes a logarithmic quadratic activation
22			* depending on the quadratic norm of a residual vector, i.e. \f[
23			* \begin{equation} log(1 + \\|\mathbf{r}\\|^2 / \alpha) \end{equation} \f] where
24			* \f$\alpha\f$ defines the width of the quadratic basin, \f$r\f$ is the scalar
25			* residual, \f$nr\f$ is the dimension of the residual vector.
26			*
27			* The computation of the function and it derivatives are carried out in
28			* `calc()` and `caldDiff()`, respectively.
29			*
30			* \sa `calc()`, `calcDiff()`, `createData()`
31			*/
32			template <typename _Scalar>
33			class ActivationModelQuadFlatLogTpl
34			: public ActivationModelAbstractTpl<_Scalar> {
35			public:
36			EIGEN_MAKE_ALIGNED_OPERATOR_NEW
37
38			typedef _Scalar Scalar;
39			typedef MathBaseTpl<Scalar> MathBase;
40			typedef ActivationModelAbstractTpl<Scalar> Base;
41			typedef ActivationDataAbstractTpl<Scalar> ActivationDataAbstract;
42			typedef ActivationDataQuadFlatLogTpl<Scalar> Data;
43			typedef typename MathBase::VectorXs VectorXs;
44			typedef typename MathBase::MatrixXs MatrixXs;
45
46			/*
47			* @brief Initialize the quadratic-flat-log activation model
48			*
49			* The default `alpha` value is defined as 1.
50			*
51			* @param[in] nr Dimension of the residual vector
52			* @param[in] alpha Width of quadratic basin (default: 1.)
53			*/
54
55		223	explicit ActivationModelQuadFlatLogTpl(const std::size_t &nr,
56			const Scalar &alpha = Scalar(1.))
57		223	: Base(nr), alpha_(alpha) {
58	✗✓	223	if (alpha < Scalar(0.)) {
59			throw_pretty("Invalid argument: "
60			<< "alpha should be a positive value");
61			}
62		223	};
63		450	virtual ~ActivationModelQuadFlatLogTpl(){};
64
65			/*
66			* @brief Compute the quadratic-flat-log function
67			*
68			* @param[in] data Quadratic-log activation data
69			* @param[in] r Residual vector \f$\mathbf{r}\in\mathbb{R}^{nr}\f$
70			*/
71		9675	virtual void calc(const boost::shared_ptr<ActivationDataAbstract> &data,
72			const Eigen::Ref<const VectorXs> &r) {
73	✓✗✗✓	9675	if (static_cast<std::size_t>(r.size()) != nr_) {
74			throw_pretty("Invalid argument: "
75			<< "r has wrong dimension (it should be " +
76			std::to_string(nr_) + ")");
77			}
78		9675	boost::shared_ptr<Data> d = boost::static_pointer_cast<Data>(data);
79	✓✗	9675	d->a0 = r.squaredNorm() / alpha_;
80		9675	data->a_value = log(Scalar(1.0) + d->a0);
81		9675	};
82
83			/*
84			* @brief Compute the derivatives of the quadratic-flat-log function
85			*
86			* @param[in] data Quadratic-log activation data
87			* @param[in] r Residual vector \f$\mathbf{r}\in\mathbb{R}^{nr}\f$
88			*/
89		304	virtual void calcDiff(const boost::shared_ptr<ActivationDataAbstract> &data,
90			const Eigen::Ref<const VectorXs> &r) {
91	✓✗✗✓	304	if (static_cast<std::size_t>(r.size()) != nr_) {
92			throw_pretty("Invalid argument: "
93			<< "r has wrong dimension (it should be " +
94			std::to_string(nr_) + ")");
95			}
96		304	boost::shared_ptr<Data> d = boost::static_pointer_cast<Data>(data);
97
98		304	d->a1 = Scalar(2.0) / (alpha_ + alpha_ * d->a0);
99	✓✗✓✗	304	data->Ar = d->a1 * r;
100	✓✗✓✗ ✓✗✓✗	304	data->Arr.diagonal() = -d->a1 * d->a1 * r.array().square();
101	✓✗✓✗	304	data->Arr.diagonal().array() += d->a1;
102		304	};
103
104			/*
105			* @brief Create the quadratic-flat-log activation data
106			*
107			* @return the activation data
108			*/
109		7837	virtual boost::shared_ptr<ActivationDataAbstract> createData() {
110	✓✗	7837	boost::shared_ptr<Data> data =
111			boost::allocate_shared<Data>(Eigen::aligned_allocator<Data>(), this);
112		15674	return data;
113			};
114
115			Scalar get_alpha() const { return alpha_; };
116			void set_alpha(const Scalar alpha) { alpha_ = alpha; };
117
118			/**
119			* @brief Print relevant information of the quadratic flat-log model
120			*
121			* @param[out] os Output stream object
122			*/
123		37	virtual void print(std::ostream &os) const {
124		37	os << "ActivationModelQuadFlatLog {nr=" << nr_ << ", a=" << alpha_ << "}";
125		37	}
126
127			protected:
128			using Base::nr_; //!< Dimension of the residual vector
129
130			private:
131			Scalar alpha_; //!< Width of quadratic basin
132			};
133
134			/*
135			* @brief Data structure of the quadratic-flat-log activation
136			*
137			* @param[in] a0 computed in calc to avoid recomputation
138			* @param[in] a1 computed in calcDiff to avoid recomputation
139			*/
140			template <typename _Scalar>
141			struct ActivationDataQuadFlatLogTpl
142			: public ActivationDataAbstractTpl<_Scalar> {
143			EIGEN_MAKE_ALIGNED_OPERATOR_NEW
144
145			typedef _Scalar Scalar;
146			typedef MathBaseTpl<Scalar> MathBase;
147			typedef ActivationDataAbstractTpl<Scalar> Base;
148
149			template <typename Activation>
150		7837	explicit ActivationDataQuadFlatLogTpl(Activation *const activation)
151		7837	: Base(activation), a0(0), a1(0) {}
152
153			Scalar a0;
154			Scalar a1;
155			};
156
157			} // namespace crocoddyl
158
159			#endif // CROCODDYL_CORE_ACTIVATIONS_QUADRATIC_FLAT_LOG_HPP_