Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	unittest/factory/activation.cpp	Lines:	72	79	91.1 %
Date:	2024-02-13 11:12:33	Branches:	44	81	54.3 %


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

#include "activation.hpp"

#include "../random_generator.hpp"
#include "crocoddyl/core/activations/2norm-barrier.hpp"
#include "crocoddyl/core/activations/quadratic-barrier.hpp"
#include "crocoddyl/core/activations/quadratic-flat-exp.hpp"
#include "crocoddyl/core/activations/quadratic-flat-log.hpp"
#include "crocoddyl/core/activations/quadratic.hpp"
#include "crocoddyl/core/activations/smooth-1norm.hpp"
#include "crocoddyl/core/activations/smooth-2norm.hpp"
#include "crocoddyl/core/activations/weighted-quadratic-barrier.hpp"
#include "crocoddyl/core/activations/weighted-quadratic.hpp"
#include "crocoddyl/core/utils/exception.hpp"

namespace crocoddyl {
namespace unittest {

const std::vector<ActivationModelTypes::Type> ActivationModelTypes::all(
    ActivationModelTypes::init_all());

std::ostream& operator<<(std::ostream& os, ActivationModelTypes::Type type) {
  switch (type) {
    case ActivationModelTypes::ActivationModelQuad:
      os << "ActivationModelQuad";
      break;
    case ActivationModelTypes::ActivationModelQuadFlatExp:
      os << "ActivationModelQuadFlatExp";
      break;
    case ActivationModelTypes::ActivationModelQuadFlatLog:
      os << "ActivationModelQuadFlatLog";
      break;
    case ActivationModelTypes::ActivationModelSmooth1Norm:
      os << "ActivationModelSmooth1Norm";
      break;
    case ActivationModelTypes::ActivationModelSmooth2Norm:
      os << "ActivationModelSmooth2Norm";
      break;
    case ActivationModelTypes::ActivationModelWeightedQuad:
      os << "ActivationModelWeightedQuad";
      break;
    case ActivationModelTypes::ActivationModelQuadraticBarrier:
      os << "ActivationModelQuadraticBarrier";
      break;
    case ActivationModelTypes::ActivationModelWeightedQuadraticBarrier:
      os << "ActivationModelWeightedQuadraticBarrier";
      break;
    case ActivationModelTypes::ActivationModel2NormBarrier:
      os << "ActivationModel2NormBarrier";
      break;
    case ActivationModelTypes::NbActivationModelTypes:
      os << "NbActivationModelTypes";
      break;
    default:
      break;
  }
  return os;
}

ActivationModelFactory::ActivationModelFactory() {}
ActivationModelFactory::~ActivationModelFactory() {}

boost::shared_ptr<crocoddyl::ActivationModelAbstract>
ActivationModelFactory::create(ActivationModelTypes::Type activation_type,
                               std::size_t nr) const {
  boost::shared_ptr<crocoddyl::ActivationModelAbstract> activation;
  Eigen::VectorXd lb = Eigen::VectorXd::Random(nr);
  Eigen::VectorXd ub =
      lb + Eigen::VectorXd::Ones(nr) + Eigen::VectorXd::Random(nr);
  Eigen::VectorXd weights = 1. * Eigen::VectorXd::Random(nr);
  double alpha = fabs(Eigen::VectorXd::Random(1)[0]);
  double eps = fabs(Eigen::VectorXd::Random(1)[0]);
  bool hessian = random_boolean();

  switch (activation_type) {
    case ActivationModelTypes::ActivationModelQuad:
      activation = boost::make_shared<crocoddyl::ActivationModelQuad>(nr);
      break;
    case ActivationModelTypes::ActivationModelQuadFlatExp:
      activation =
          boost::make_shared<crocoddyl::ActivationModelQuadFlatExp>(nr, alpha);
      break;
    case ActivationModelTypes::ActivationModelQuadFlatLog:
      activation =
          boost::make_shared<crocoddyl::ActivationModelQuadFlatLog>(nr, alpha);
      break;
    case ActivationModelTypes::ActivationModelSmooth1Norm:
      activation =
          boost::make_shared<crocoddyl::ActivationModelSmooth1Norm>(nr, eps);
      break;
    case ActivationModelTypes::ActivationModelSmooth2Norm:
      activation =
          boost::make_shared<crocoddyl::ActivationModelSmooth2Norm>(nr, eps);
      break;
    case ActivationModelTypes::ActivationModelWeightedQuad:
      activation =
          boost::make_shared<crocoddyl::ActivationModelWeightedQuad>(weights);
      break;
    case ActivationModelTypes::ActivationModelQuadraticBarrier:
      activation =
          boost::make_shared<crocoddyl::ActivationModelQuadraticBarrier>(
              crocoddyl::ActivationBounds(lb, ub));
      break;
    case ActivationModelTypes::ActivationModelWeightedQuadraticBarrier:
      activation = boost::make_shared<
          crocoddyl::ActivationModelWeightedQuadraticBarrier>(
          crocoddyl::ActivationBounds(lb, ub), weights);
      break;
    case ActivationModelTypes::ActivationModel2NormBarrier:
      activation = boost::make_shared<crocoddyl::ActivationModel2NormBarrier>(
          nr, alpha, hessian);
      break;
    default:
      throw_pretty(__FILE__ ":\n Construct wrong ActivationModelTypes::Type");
      break;
  }
  return activation;
}

}  // namespace unittest
}  // namespace crocoddyl


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			///////////////////////////////////////////////////////////////////////////////
2			// BSD 3-Clause License
3			//
4			// Copyright (C) 2019-2021, LAAS-CNRS, University of Edinburgh
5			// Copyright note valid unless otherwise stated in individual files.
6			// All rights reserved.
7			///////////////////////////////////////////////////////////////////////////////
8
9			#include "activation.hpp"
10
11			#include "../random_generator.hpp"
12			#include "crocoddyl/core/activations/2norm-barrier.hpp"
13			#include "crocoddyl/core/activations/quadratic-barrier.hpp"
14			#include "crocoddyl/core/activations/quadratic-flat-exp.hpp"
15			#include "crocoddyl/core/activations/quadratic-flat-log.hpp"
16			#include "crocoddyl/core/activations/quadratic.hpp"
17			#include "crocoddyl/core/activations/smooth-1norm.hpp"
18			#include "crocoddyl/core/activations/smooth-2norm.hpp"
19			#include "crocoddyl/core/activations/weighted-quadratic-barrier.hpp"
20			#include "crocoddyl/core/activations/weighted-quadratic.hpp"
21			#include "crocoddyl/core/utils/exception.hpp"
22
23			namespace crocoddyl {
24			namespace unittest {
25
26			const std::vector<ActivationModelTypes::Type> ActivationModelTypes::all(
27			ActivationModelTypes::init_all());
28
29		423	std::ostream& operator<<(std::ostream& os, ActivationModelTypes::Type type) {
30	✓✓✓✓ ✓✓✓✓ ✓✗✗	423	switch (type) {
31		52	case ActivationModelTypes::ActivationModelQuad:
32		52	os << "ActivationModelQuad";
33		52	break;
34		52	case ActivationModelTypes::ActivationModelQuadFlatExp:
35		52	os << "ActivationModelQuadFlatExp";
36		52	break;
37		52	case ActivationModelTypes::ActivationModelQuadFlatLog:
38		52	os << "ActivationModelQuadFlatLog";
39		52	break;
40		52	case ActivationModelTypes::ActivationModelSmooth1Norm:
41		52	os << "ActivationModelSmooth1Norm";
42		52	break;
43		52	case ActivationModelTypes::ActivationModelSmooth2Norm:
44		52	os << "ActivationModelSmooth2Norm";
45		52	break;
46		52	case ActivationModelTypes::ActivationModelWeightedQuad:
47		52	os << "ActivationModelWeightedQuad";
48		52	break;
49		37	case ActivationModelTypes::ActivationModelQuadraticBarrier:
50		37	os << "ActivationModelQuadraticBarrier";
51		37	break;
52		37	case ActivationModelTypes::ActivationModelWeightedQuadraticBarrier:
53		37	os << "ActivationModelWeightedQuadraticBarrier";
54		37	break;
55		37	case ActivationModelTypes::ActivationModel2NormBarrier:
56		37	os << "ActivationModel2NormBarrier";
57		37	break;
58			case ActivationModelTypes::NbActivationModelTypes:
59			os << "NbActivationModelTypes";
60			break;
61			default:
62			break;
63			}
64		423	return os;
65			}
66
67		4448	ActivationModelFactory::ActivationModelFactory() {}
68		4448	ActivationModelFactory::~ActivationModelFactory() {}
69
70			boost::shared_ptr<crocoddyl::ActivationModelAbstract>
71		4448	ActivationModelFactory::create(ActivationModelTypes::Type activation_type,
72			std::size_t nr) const {
73		4448	boost::shared_ptr<crocoddyl::ActivationModelAbstract> activation;
74	✓✗✓✗	8896	Eigen::VectorXd lb = Eigen::VectorXd::Random(nr);
75			Eigen::VectorXd ub =
76	✓✗✓✗ ✓✗✓✗ ✓✗	8896	lb + Eigen::VectorXd::Ones(nr) + Eigen::VectorXd::Random(nr);
77	✓✗✓✗ ✓✗	8896	Eigen::VectorXd weights = 1. * Eigen::VectorXd::Random(nr);
78	✓✗✓✗	4448	double alpha = fabs(Eigen::VectorXd::Random(1)[0]);
79	✓✗✓✗	4448	double eps = fabs(Eigen::VectorXd::Random(1)[0]);
80	✓✗	4448	bool hessian = random_boolean();
81
82	✓✓✓✓ ✓✓✓✓ ✓✗	4448	switch (activation_type) {
83		2789	case ActivationModelTypes::ActivationModelQuad:
84	✓✗	2789	activation = boost::make_shared<crocoddyl::ActivationModelQuad>(nr);
85		2789	break;
86		222	case ActivationModelTypes::ActivationModelQuadFlatExp:
87			activation =
88	✓✗	222	boost::make_shared<crocoddyl::ActivationModelQuadFlatExp>(nr, alpha);
89		222	break;
90		222	case ActivationModelTypes::ActivationModelQuadFlatLog:
91			activation =
92	✓✗	222	boost::make_shared<crocoddyl::ActivationModelQuadFlatLog>(nr, alpha);
93		222	break;
94		222	case ActivationModelTypes::ActivationModelSmooth1Norm:
95			activation =
96	✓✗	222	boost::make_shared<crocoddyl::ActivationModelSmooth1Norm>(nr, eps);
97		222	break;
98		222	case ActivationModelTypes::ActivationModelSmooth2Norm:
99			activation =
100	✓✗	222	boost::make_shared<crocoddyl::ActivationModelSmooth2Norm>(nr, eps);
101		222	break;
102		222	case ActivationModelTypes::ActivationModelWeightedQuad:
103			activation =
104	✓✗	222	boost::make_shared<crocoddyl::ActivationModelWeightedQuad>(weights);
105		222	break;
106		183	case ActivationModelTypes::ActivationModelQuadraticBarrier:
107			activation =
108	✓✗	366	boost::make_shared<crocoddyl::ActivationModelQuadraticBarrier>(
109	✓✗	549	crocoddyl::ActivationBounds(lb, ub));
110		183	break;
111		183	case ActivationModelTypes::ActivationModelWeightedQuadraticBarrier:
112			activation = boost::make_shared<
113	✓✗	366	crocoddyl::ActivationModelWeightedQuadraticBarrier>(
114	✓✗	549	crocoddyl::ActivationBounds(lb, ub), weights);
115		183	break;
116		183	case ActivationModelTypes::ActivationModel2NormBarrier:
117	✓✗	366	activation = boost::make_shared<crocoddyl::ActivationModel2NormBarrier>(
118		183	nr, alpha, hessian);
119		183	break;
120			default:
121			throw_pretty(__FILE__ ":\n Construct wrong ActivationModelTypes::Type");
122			break;
123			}
124		8896	return activation;
125			}
126
127			} // namespace unittest
128			} // namespace crocoddyl