cart-elc

Source code for CART-ELC
git clone git://git.laack.co/cart-elc.git
Log | Files | Refs | README | LICENSE

level1_real_impl.h (4267B)

      1 // This file is part of Eigen, a lightweight C++ template library
      2 // for linear algebra.
      3 //
      4 // Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr>
      5 //
      6 // This Source Code Form is subject to the terms of the Mozilla
      7 // Public License v. 2.0. If a copy of the MPL was not distributed
      8 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
      9 
     10 #include "common.h"
     11 
     12 // computes the sum of magnitudes of all vector elements or, for a complex vector x, the sum
     13 // res = |Rex1| + |Imx1| + |Rex2| + |Imx2| + ... + |Rexn| + |Imxn|, where x is a vector of order n
     14 RealScalar EIGEN_BLAS_FUNC(asum)(int *n, RealScalar *px, int *incx)
     15 {
     16 //   std::cerr << "_asum " << *n << " " << *incx << "\n";
     17 
     18   Scalar* x = reinterpret_cast<Scalar*>(px);
     19 
     20   if(*n<=0) return 0;
     21 
     22   if(*incx==1)  return make_vector(x,*n).cwiseAbs().sum();
     23   else          return make_vector(x,*n,std::abs(*incx)).cwiseAbs().sum();
     24 }
     25 
     26 int EIGEN_CAT(i, EIGEN_BLAS_FUNC(amax))(int *n, RealScalar *px, int *incx)
     27 {
     28   if(*n<=0) return 0;
     29   Scalar* x = reinterpret_cast<Scalar*>(px);
     30 
     31   DenseIndex ret;
     32   if(*incx==1)  make_vector(x,*n).cwiseAbs().maxCoeff(&ret);
     33   else          make_vector(x,*n,std::abs(*incx)).cwiseAbs().maxCoeff(&ret);
     34   return int(ret)+1;
     35 }
     36 
     37 int EIGEN_CAT(i, EIGEN_BLAS_FUNC(amin))(int *n, RealScalar *px, int *incx)
     38 {
     39   if(*n<=0) return 0;
     40   Scalar* x = reinterpret_cast<Scalar*>(px);
     41 
     42   DenseIndex ret;
     43   if(*incx==1)  make_vector(x,*n).cwiseAbs().minCoeff(&ret);
     44   else          make_vector(x,*n,std::abs(*incx)).cwiseAbs().minCoeff(&ret);
     45   return int(ret)+1;
     46 }
     47 
     48 // computes a vector-vector dot product.
     49 Scalar EIGEN_BLAS_FUNC(dot)(int *n, RealScalar *px, int *incx, RealScalar *py, int *incy)
     50 {
     51 //   std::cerr << "_dot " << *n << " " << *incx << " " << *incy << "\n";
     52 
     53   if(*n<=0) return 0;
     54 
     55   Scalar* x = reinterpret_cast<Scalar*>(px);
     56   Scalar* y = reinterpret_cast<Scalar*>(py);
     57 
     58   if(*incx==1 && *incy==1)    return (make_vector(x,*n).cwiseProduct(make_vector(y,*n))).sum();
     59   else if(*incx>0 && *incy>0) return (make_vector(x,*n,*incx).cwiseProduct(make_vector(y,*n,*incy))).sum();
     60   else if(*incx<0 && *incy>0) return (make_vector(x,*n,-*incx).reverse().cwiseProduct(make_vector(y,*n,*incy))).sum();
     61   else if(*incx>0 && *incy<0) return (make_vector(x,*n,*incx).cwiseProduct(make_vector(y,*n,-*incy).reverse())).sum();
     62   else if(*incx<0 && *incy<0) return (make_vector(x,*n,-*incx).reverse().cwiseProduct(make_vector(y,*n,-*incy).reverse())).sum();
     63   else return 0;
     64 }
     65 
     66 // computes the Euclidean norm of a vector.
     67 // FIXME
     68 Scalar EIGEN_BLAS_FUNC(nrm2)(int *n, RealScalar *px, int *incx)
     69 {
     70 //   std::cerr << "_nrm2 " << *n << " " << *incx << "\n";
     71   if(*n<=0) return 0;
     72 
     73   Scalar* x = reinterpret_cast<Scalar*>(px);
     74 
     75   if(*incx==1)  return make_vector(x,*n).stableNorm();
     76   else          return make_vector(x,*n,std::abs(*incx)).stableNorm();
     77 }
     78 
     79 int EIGEN_BLAS_FUNC(rot)(int *n, RealScalar *px, int *incx, RealScalar *py, int *incy, RealScalar *pc, RealScalar *ps)
     80 {
     81 //   std::cerr << "_rot " << *n << " " << *incx << " " << *incy << "\n";
     82   if(*n<=0) return 0;
     83 
     84   Scalar* x = reinterpret_cast<Scalar*>(px);
     85   Scalar* y = reinterpret_cast<Scalar*>(py);
     86   Scalar c = *reinterpret_cast<Scalar*>(pc);
     87   Scalar s = *reinterpret_cast<Scalar*>(ps);
     88 
     89   StridedVectorType vx(make_vector(x,*n,std::abs(*incx)));
     90   StridedVectorType vy(make_vector(y,*n,std::abs(*incy)));
     91 
     92   Reverse<StridedVectorType> rvx(vx);
     93   Reverse<StridedVectorType> rvy(vy);
     94 
     95        if(*incx<0 && *incy>0) internal::apply_rotation_in_the_plane(rvx, vy, JacobiRotation<Scalar>(c,s));
     96   else if(*incx>0 && *incy<0) internal::apply_rotation_in_the_plane(vx, rvy, JacobiRotation<Scalar>(c,s));
     97   else                        internal::apply_rotation_in_the_plane(vx, vy,  JacobiRotation<Scalar>(c,s));
     98 
     99 
    100   return 0;
    101 }
    102 
    103 /*
    104 // performs rotation of points in the modified plane.
    105 int EIGEN_BLAS_FUNC(rotm)(int *n, RealScalar *px, int *incx, RealScalar *py, int *incy, RealScalar *param)
    106 {
    107   Scalar* x = reinterpret_cast<Scalar*>(px);
    108   Scalar* y = reinterpret_cast<Scalar*>(py);
    109 
    110   // TODO
    111 
    112   return 0;
    113 }
    114 
    115 // computes the modified parameters for a Givens rotation.
    116 int EIGEN_BLAS_FUNC(rotmg)(RealScalar *d1, RealScalar *d2, RealScalar *x1, RealScalar *x2, RealScalar *param)
    117 {
    118   // TODO
    119 
    120   return 0;
    121 }
    122 */