apollo::prediction::math_util 命名空间参考

函数
double	Normalize (const double value, const double mean, const double std)
	Normalize the value by specified mean and standard deviation.
double	Relu (const double value)
	RELU function used in neural networks as an activation function.
std::vector< double >	Softmax (const std::vector< double > &value, bool use_exp=true)
	Softmax function used in neural networks as an activation function.
int	SolveQuadraticEquation (const std::vector< double > &coefficients, std::pair< double, double > *roots)
	Solve quadratic equation.
double	EvaluateQuinticPolynomial (const std::array< double, 6 > &coeffs, const double t, const uint32_t order, const double end_t, const double end_v)
	Evaluate quintic polynomial.
double	EvaluateQuarticPolynomial (const std::array< double, 5 > &coeffs, const double t, const uint32_t order, const double end_t, const double end_v)
	Evaluate quartic polynomial.
double	EvaluateCubicPolynomial (const std::array< double, 4 > &coefs, const double t, const uint32_t order, const double end_t=std::numeric_limits< double >::infinity(), const double end_v=0.0)
	Evaluate cubic polynomial.
double	GetSByConstantAcceleration (const double v0, const double acceleration, const double t)
template<std::size_t N>
std::array< double, 2 *N - 2 >	ComputePolynomial (const std::array< double, N - 1 > &start_state, const std::array< double, N - 1 > &end_state, const double param)
template<>
std::array< double, 4 >	ComputePolynomial< 3 > (const std::array< double, 2 > &start_state, const std::array< double, 2 > &end_state, const double param)

函数说明

ComputePolynomial()

template<std::size_t N>

std::array< double, 2 *N - 2 > apollo::prediction::math_util::ComputePolynomial	(	const std::array< double, N - 1 > &	start_state,
		const std::array< double, N - 1 > &	end_state,
		const double	param
	)

ComputePolynomial< 3 >()

template<>

std::array< double, 4 > apollo::prediction::math_util::ComputePolynomial< 3 > ( const std::array< double, 2 > &  start_state, const std::array< double, 2 > &  end_state, const double  param  )

inline

在文件 prediction_util.h 第 97 行定义.

                                                              {
  std::array<double, 4> coefs;
  coefs[0] = start_state[0];
  coefs[1] = start_state[1];
 
  auto m0 = end_state[0] - start_state[0] - start_state[1] * param;
  auto m1 = end_state[1] - start_state[1];
 
  auto param_p3 = param * param * param;
  coefs[3] = (m1 * param - 2.0 * m0) / param_p3;
 
  coefs[2] = (m1 - 3.0 * coefs[3] * param * param) / param * 0.5;
  return coefs;
}

EvaluateCubicPolynomial()

double apollo::prediction::math_util::EvaluateCubicPolynomial	(	const std::array< double, 4 > &	coefs,
		const double	t,
		const uint32_t	order,
		const double	end_t = std::numeric_limits< double >::infinity(),
		const double	end_v = 0.0
	)

Evaluate cubic polynomial.

参数

coefficients	of the cubic polynomial, lower to higher.
parameter	of the cubic polynomial.
end_t	ending time for extrapolation.
end_v	ending velocity for extrapolation.

返回

order of derivative to evaluate.

在文件 prediction_util.cc 第 175 行定义.

                                                                       {
  if (t > end_t) {
    switch (order) {
      case 0: {
        double end_value =
            ((coefs[3] * end_t + coefs[2]) * end_t + coefs[1]) * end_t +
            coefs[0];
        return end_value + (t - end_t) * end_v;
      }
      case 1: {
        return end_v;
      }
      default: { return 0.0; }
    }
  }
 
  switch (order) {
    case 0: {
      return ((coefs[3] * t + coefs[2]) * t + coefs[1]) * t + coefs[0];
    }
    case 1: {
      return (3.0 * coefs[3] * t + 2.0 * coefs[2]) * t + coefs[1];
    }
    case 2: {
      return 6.0 * coefs[3] * t + 2.0 * coefs[2];
    }
    case 3: {
      return 6.0 * coefs[3];
    }
    default:
      return 0.0;
  }
}

EvaluateQuarticPolynomial()

double apollo::prediction::math_util::EvaluateQuarticPolynomial	(	const std::array< double, 5 > &	coeffs,
		const double	t,
		const uint32_t	order,
		const double	end_t,
		const double	end_v
	)

Evaluate quartic polynomial.

参数

coefficients	of the quartic polynomial, lower to higher.
parameter	of the quartic polynomial.

返回

order of derivative to evaluate.

在文件 prediction_util.cc 第 131 行定义.

                                                                         {
  if (t >= end_t) {
    switch (order) {
      case 0: {
        double end_value =
            (((coeffs[4] * end_t + coeffs[3]) * end_t + coeffs[2]) * end_t +
             coeffs[1]) *
                end_t +
            coeffs[0];
        return end_value + (t - end_t) * end_v;
      }
      case 1: {
        return end_v;
      }
      default: { return 0.0; }
    }
  }
  switch (order) {
    case 0: {
      return (((coeffs[4] * t + coeffs[3]) * t + coeffs[2]) * t + coeffs[1]) *
                 t +
             coeffs[0];
    }
    case 1: {
      return ((4.0 * coeffs[4] * t + 3.0 * coeffs[3]) * t + 2.0 * coeffs[2]) *
                 t +
             coeffs[1];
    }
    case 2: {
      return (12.0 * coeffs[4] * t + 6.0 * coeffs[3]) * t + 2.0 * coeffs[2];
    }
    case 3: {
      return 24.0 * coeffs[4] * t + 6.0 * coeffs[3];
    }
    case 4: {
      return 24.0 * coeffs[4];
    }
    default:
      return 0.0;
  }
}

EvaluateQuinticPolynomial()

double apollo::prediction::math_util::EvaluateQuinticPolynomial	(	const std::array< double, 6 > &	coeffs,
		const double	t,
		const uint32_t	order,
		const double	end_t,
		const double	end_v
	)

Evaluate quintic polynomial.

参数

coefficients	of the quintic polynomial, lower to higher.
parameter	of the quintic polynomial.

返回

order of derivative to evaluate.

在文件 prediction_util.cc 第 75 行定义.

                                                                         {
  if (t >= end_t) {
    switch (order) {
      case 0: {
        double end_value =
            ((((coeffs[5] * end_t + coeffs[4]) * end_t + coeffs[3]) * end_t +
              coeffs[2]) *
                 end_t +
             coeffs[1]) *
                end_t +
            coeffs[0];
        return end_value + end_v * (t - end_t);
      }
      case 1: {
        return end_v;
      }
      default: { return 0.0; }
    }
  }
  switch (order) {
    case 0: {
      return ((((coeffs[5] * t + coeffs[4]) * t + coeffs[3]) * t + coeffs[2]) *
                  t +
              coeffs[1]) *
                 t +
             coeffs[0];
    }
    case 1: {
      return (((5.0 * coeffs[5] * t + 4.0 * coeffs[4]) * t + 3.0 * coeffs[3]) *
                  t +
              2.0 * coeffs[2]) *
                 t +
             coeffs[1];
    }
    case 2: {
      return (((20.0 * coeffs[5] * t + 12.0 * coeffs[4]) * t) +
              6.0 * coeffs[3]) *
                 t +
             2.0 * coeffs[2];
    }
    case 3: {
      return (60.0 * coeffs[5] * t + 24.0 * coeffs[4]) * t + 6.0 * coeffs[3];
    }
    case 4: {
      return 120.0 * coeffs[5] * t + 24.0 * coeffs[4];
    }
    case 5: {
      return 120.0 * coeffs[5];
    }
    default:
      return 0.0;
  }
}

GetSByConstantAcceleration()

double apollo::prediction::math_util::GetSByConstantAcceleration	(	const double	v0,
		const double	acceleration,
		const double	t
	)

在文件 prediction_util.cc 第 211 行定义.

                                                  {
  if (acceleration > -FLAGS_double_precision) {
    return v0 * t + 0.5 * acceleration * t * t;
  }
  double t_stop = v0 / (-acceleration);
  double t_actual = std::min(t, t_stop);
  return v0 * t_actual + 0.5 * acceleration * t_actual * t_actual;
}

Normalize()

double apollo::prediction::math_util::Normalize	(	const double	value,
		const double	mean,
		const double	std
	)

Normalize the value by specified mean and standard deviation.

参数

value	The value to be normalized.
mean	The mean used for normalization.
std	The standard deviation used for normalization.

返回

The normalized value.

在文件 prediction_util.cc 第 28 行定义.

                                                                          {
  const double eps = 1e-10;
  return (value - mean) / (std + eps);
}

Relu()

double apollo::prediction::math_util::Relu

(

const double

value

)

RELU function used in neural networks as an activation function.

参数

value

The input.

返回

The output of RELU function.

在文件 prediction_util.cc 第 33 行定义.

{ return (value > 0.0) ? value : 0.0; }

Softmax()

std::vector< double > apollo::prediction::math_util::Softmax	(	const std::vector< double > &	value,
		bool	use_exp = true
	)

Softmax function used in neural networks as an activation function.

参数

vector

The input.

返回

The output of Softmax function.

在文件 prediction_util.cc 第 35 行定义.

                                                                        {
  std::vector<double> result;
  double sum = 0.0;
  for (std::size_t i = 0; i < value.size(); ++i) {
    double exp_value = std::max(0.001, value[i]);
    if (use_exp) {
      exp_value = std::exp(value[i]);
    }
    sum += exp_value;
    result.push_back(exp_value);
  }
  for (std::size_t i = 0; i < value.size(); ++i) {
    result[i] = result[i] / sum;
  }
  return result;
}

SolveQuadraticEquation()

int apollo::prediction::math_util::SolveQuadraticEquation	(	const std::vector< double > &	coefficients,
		std::pair< double, double > *	roots
	)

Solve quadratic equation.

参数

coefficients	The coefficients of quadratic equation.
roots	Two roots of the equation if any.

返回

An integer indicating the success of solving equation.

在文件 prediction_util.cc 第 52 行定义.

                                                           {
  if (coefficients.size() != 3) {
    return -1;
  }
  const double a = coefficients[0];
  const double b = coefficients[1];
  const double c = coefficients[2];
  if (std::fabs(a) <= std::numeric_limits<double>::epsilon()) {
    return -1;
  }
 
  double delta = b * b - 4.0 * a * c;
  if (delta < 0.0) {
    return -1;
  }
 
  double sqrt_delta = std::sqrt(delta);
  roots->first = (-b + sqrt_delta) * 0.5 / a;
  roots->second = (-b - sqrt_delta) * 0.5 / a;
  return 0;
}