#include <cmath>
#include <algorithm>
#include <limits>
#include <vector>
#include "Array.h"
#include "CColVector.h"
#include "CMatrix.h"
#include "CRowVector.h"
#include "CSparse.h"
#include "MArray.h"
#include "dColVector.h"
#include "dDiagMatrix.h"
#include "dMatrix.h"
#include "dRowVector.h"
#include "dSparse.h"
#include "fCColVector.h"
#include "fCMatrix.h"
#include "fCRowVector.h"
#include "fColVector.h"
#include "fDiagMatrix.h"
#include "fMatrix.h"
#include "fRowVector.h"
#include "lo-error.h"
#include "lo-ieee.h"
#include "lo-mappers.h"
#include "mx-cm-s.h"
#include "mx-fcm-fs.h"
#include "mx-fs-fcm.h"
#include "mx-s-cm.h"
#include "oct-cmplx.h"
#include "oct-norm.h"
#include "quit.h"
#include "svd.h"

Include dependency graph for oct-norm.cc:

Classes
class	octave::norm_accumulator_0< R >

class	octave::norm_accumulator_1< R >

class	octave::norm_accumulator_2< R >

class	octave::norm_accumulator_inf< R >

class	octave::norm_accumulator_minf< R >

class	octave::norm_accumulator_mp< R >

class	octave::norm_accumulator_p< R >

Namespaces
namespace	octave

Macros
#define	DEFINE_COLROW_NORM_FUNCS(PREFIX, RPREFIX, RTYPE)

#define	DEFINE_DISPATCHER(FUNC_NAME, ARG_TYPE, RES_TYPE)

#define	DEFINE_XNORM_FUNCS(PREFIX, RTYPE)

#define	DEFINE_XNORM_SPARSE_FUNCS(PREFIX, RTYPE)

Functions
template<typename T , typename R >
void	octave::array_norm_2 (const T *v, octave_idx_type n, R &res)

template<typename T , typename R , typename ACC >
void	octave::column_norms (const MArray< T > &m, MArray< R > &res, ACC acc)

template<typename T , typename R >
MArray< R >	octave::column_norms (const MArray< T > &v, R p)

template<typename T , typename R , typename ACC >
void	octave::column_norms (const MSparse< T > &m, MArray< R > &res, ACC acc)

template<typename T , typename R >
MArray< R >	octave::column_norms (const MSparse< T > &v, R p)

template<typename VectorT , typename R >
VectorT	octave::dual_p (const VectorT &x, R p, R q)

template<typename T , typename R >
T	octave::elem_dual_p (T x, R p)

template<typename MatrixT , typename VectorT , typename R >
R	octave::higham (const MatrixT &m, R p, R tol, int maxiter, VectorT &x)

template<typename ColVectorT , typename R >
static void	octave::higham_subp (const ColVectorT &y, const ColVectorT &col, octave_idx_type nsamp, R p, R &lambda, R &mu)

template<typename ColVectorT , typename R >
static void	octave::higham_subp (const ColVectorT &y, const ColVectorT &col, octave_idx_type nsamp, R p, std::complex< R > &lambda, std::complex< R > &mu)

template<typename MatrixT , typename VectorT , typename R >
R	octave::matrix_norm (const MatrixT &m, R p, VectorT)

template<typename T , typename R , typename ACC >
void	octave::row_norms (const MArray< T > &m, MArray< R > &res, ACC acc)

template<typename T , typename R >
MArray< R >	octave::row_norms (const MArray< T > &v, R p)

template<typename T , typename R , typename ACC >
void	octave::row_norms (const MSparse< T > &m, MArray< R > &res, ACC acc)

template<typename T , typename R >
MArray< R >	octave::row_norms (const MSparse< T > &v, R p)

template<typename MatrixT , typename VectorT , typename R >
R	octave::svd_matrix_norm (const MatrixT &m, R p, VectorT)

template<typename T , typename R , typename ACC >
void	octave::vector_norm (const Array< T > &v, R &res, ACC acc)

template<typename T , typename R >
R	octave::vector_norm (const MArray< T > &v, R p)

RowVector	octave::xcolnorms (const ComplexMatrix &m, double p)

FloatRowVector	octave::xcolnorms (const FloatComplexMatrix &m, float p)

FloatRowVector	octave::xcolnorms (const FloatMatrix &m, float p)

RowVector	octave::xcolnorms (const Matrix &m, double p)

RowVector	octave::xcolnorms (const SparseComplexMatrix &m, double p)

RowVector	octave::xcolnorms (const SparseMatrix &m, double p)

double	octave::xfrobnorm (const ComplexMatrix &x)

float	octave::xfrobnorm (const FloatComplexMatrix &x)

float	octave::xfrobnorm (const FloatMatrix &x)

double	octave::xfrobnorm (const Matrix &x)

double	octave::xfrobnorm (const SparseComplexMatrix &x)

double	octave::xfrobnorm (const SparseMatrix &x)

double	octave::xnorm (const ColumnVector &x, double p)

double	octave::xnorm (const ComplexColumnVector &x, double p)

double	octave::xnorm (const ComplexMatrix &x, double p)

double	octave::xnorm (const ComplexRowVector &x, double p)

float	octave::xnorm (const FloatColumnVector &x, float p)

float	octave::xnorm (const FloatComplexColumnVector &x, float p)

float	octave::xnorm (const FloatComplexMatrix &x, float p)

float	octave::xnorm (const FloatComplexRowVector &x, float p)

float	octave::xnorm (const FloatMatrix &x, float p)

float	octave::xnorm (const FloatRowVector &x, float p)

double	octave::xnorm (const Matrix &x, double p)

double	octave::xnorm (const RowVector &x, double p)

double	octave::xnorm (const SparseComplexMatrix &x, double p)

double	octave::xnorm (const SparseMatrix &x, double p)

ColumnVector	octave::xrownorms (const ComplexMatrix &m, double p)

FloatColumnVector	octave::xrownorms (const FloatComplexMatrix &m, float p)

FloatColumnVector	octave::xrownorms (const FloatMatrix &m, float p)

ColumnVector	octave::xrownorms (const Matrix &m, double p)

ColumnVector	octave::xrownorms (const SparseComplexMatrix &m, double p)

ColumnVector	octave::xrownorms (const SparseMatrix &m, double p)

Variables
static int	octave::max_norm_iter = 100

static const char *	octave::p_less1_gripe = "xnorm: p must be >= 1"

Macro Definition Documentation

◆ DEFINE_COLROW_NORM_FUNCS

#define DEFINE_COLROW_NORM_FUNCS	(	PREFIX,
		RPREFIX,
		RTYPE
	)

Value:

  RPREFIX##RowVector                                            \
  xcolnorms (const PREFIX##Matrix& m, RTYPE p)                  \
  {                                                             \
    return column_norms (m, p);                                 \
  }                                                             \
  RPREFIX##ColumnVector                                         \
  xrownorms (const PREFIX##Matrix& m, RTYPE p)                  \
  {                                                             \
    return row_norms (m, p);                                    \
  }                                                             \

Definition at line 616 of file oct-norm.cc.

◆ DEFINE_DISPATCHER

#define DEFINE_DISPATCHER	(	FUNC_NAME,
		ARG_TYPE,
		RES_TYPE
	)

Value:

  template <typename T, typename R>                             \
  RES_TYPE FUNC_NAME (const ARG_TYPE& v, R p)                   \
  {                                                             \
    RES_TYPE res;                                               \
    if (p == 2)                                                 \
      FUNC_NAME (v, res, norm_accumulator_2<R> ());             \
    else if (p == 1)                                            \
      FUNC_NAME (v, res, norm_accumulator_1<R> ());             \
    else if (lo_ieee_isinf (p))                                 \
      {                                                         \
        if (p > 0)                                              \
          FUNC_NAME (v, res, norm_accumulator_inf<R> ());       \
        else                                                    \
          FUNC_NAME (v, res, norm_accumulator_minf<R> ());      \
      }                                                         \
    else if (p == 0)                                            \
      FUNC_NAME (v, res, norm_accumulator_0<R> ());             \
    else if (p > 0)                                             \
      FUNC_NAME (v, res, norm_accumulator_p<R> (p));            \
    else                                                        \
      FUNC_NAME (v, res, norm_accumulator_mp<R> (p));           \
    return res;                                                 \
  }

Definition at line 323 of file oct-norm.cc.

◆ DEFINE_XNORM_FUNCS

#define DEFINE_XNORM_FUNCS	(	PREFIX,
		RTYPE
	)

Value:

  RTYPE xnorm (const PREFIX##ColumnVector& x, RTYPE p)                  \
  {                                                                     \
    return vector_norm (x, p);                                          \
  }                                                                     \
  RTYPE xnorm (const PREFIX##RowVector& x, RTYPE p)                     \
  {                                                                     \
    return vector_norm (x, p);                                          \
  }                                                                     \
  RTYPE xnorm (const PREFIX##Matrix& x, RTYPE p)                        \
  {                                                                     \
    return svd_matrix_norm (x, p, PREFIX##Matrix ());                   \
  }                                                                     \
  RTYPE xfrobnorm (const PREFIX##Matrix& x)                             \
  {                                                                     \
    return vector_norm (x, static_cast<RTYPE> (2));                     \
  }

Definition at line 567 of file oct-norm.cc.

◆ DEFINE_XNORM_SPARSE_FUNCS

#define DEFINE_XNORM_SPARSE_FUNCS	(	PREFIX,
		RTYPE
	)

Value:

  RTYPE xnorm (const Sparse##PREFIX##Matrix& x, RTYPE p)        \
  {                                                             \
    return matrix_norm (x, p, PREFIX##Matrix ());               \
  }                                                             \
  RTYPE xfrobnorm (const Sparse##PREFIX##Matrix& x)             \
  {                                                             \
    RTYPE res;                                                  \
    array_norm_2 (x.data (), x.nnz (), res);                    \
    return res;                                                 \
  }

Definition at line 601 of file oct-norm.cc.

Classes

Namespaces

Macros

Functions

Variables

Macro Definition Documentation

◆ DEFINE_COLROW_NORM_FUNCS

◆ DEFINE_DISPATCHER

◆ DEFINE_XNORM_FUNCS

◆ DEFINE_XNORM_SPARSE_FUNCS