IT++ Logo
copy_vector.cpp
Go to the documentation of this file.
00001 
00029 #include <itpp/base/copy_vector.h>
00030 
00031 #ifndef _MSC_VER
00032 #  include <itpp/config.h>
00033 #else
00034 #  include <itpp/config_msvc.h>
00035 #endif
00036 
00037 #if defined (HAVE_BLAS)
00038 #  include <itpp/base/blas.h>
00039 #endif
00040 
00041 
00042 namespace itpp
00043 {
00044 
00045 #if defined (HAVE_BLAS)
00046 void copy_vector(int n, const double *x, double *y)
00047 {
00048   int incr = 1;
00049   blas::dcopy_(&n, x, &incr, y, &incr);
00050 }
00051 void copy_vector(int n, const std::complex<double> *x, std::complex<double> *y)
00052 {
00053   int incr = 1;
00054   blas::zcopy_(&n, x, &incr, y, &incr);
00055 }
00056 #else
00057 void copy_vector(int n, const double *x, double *y)
00058 {
00059   memcpy(y, x, static_cast<unsigned int>(n) * sizeof(double));
00060 }
00061 void copy_vector(int n, const std::complex<double> *x, std::complex<double> *y)
00062 {
00063   memcpy(y, x, static_cast<unsigned int>(n) * sizeof(std::complex<double>));
00064 }
00065 #endif
00066 
00067 
00068 #if defined (HAVE_BLAS)
00069 void copy_vector(int n, const double *x, int incx, double *y, int incy)
00070 {
00071   blas::dcopy_(&n, x, &incx, y, &incy);
00072 }
00073 void copy_vector(int n, const std::complex<double> *x, int incx,
00074                  std::complex<double> *y, int incy)
00075 {
00076   blas::zcopy_(&n, x, &incx, y, &incy);
00077 }
00078 #else
00079 void copy_vector(int n, const double *x, int incx, double *y, int incy)
00080 {
00081   for (int i = 0; i < n; i++)
00082     y[i*incy] = x[i*incx];
00083 }
00084 void copy_vector(int n, const std::complex<double> *x, int incx,
00085                  std::complex<double> *y, int incy)
00086 {
00087   for (int i = 0; i < n; i++)
00088     y[i*incy] = x[i*incx];
00089 }
00090 #endif
00091 
00092 
00093 #if defined (HAVE_BLAS)
00094 void swap_vector(int n, double *x, double *y)
00095 {
00096   int incr = 1;
00097   blas::dswap_(&n, x, &incr, y, &incr);
00098 }
00099 void swap_vector(int n, std::complex<double> *x, std::complex<double> *y)
00100 {
00101   int incr = 1;
00102   blas::zswap_(&n, x, &incr, y, &incr);
00103 }
00104 #else
00105 void swap_vector(int n, double *x, double *y)
00106 {
00107   for (int i = 0; i < n; i++)
00108     std::swap(x[i], y[i]);
00109 }
00110 void swap_vector(int n, std::complex<double> *x, std::complex<double> *y)
00111 {
00112   for (int i = 0; i < n; i++)
00113     std::swap(x[i], y[i]);
00114 }
00115 #endif
00116 
00117 
00118 #if defined (HAVE_BLAS)
00119 void swap_vector(int n, double *x, int incx, double *y, int incy)
00120 {
00121   blas::dswap_(&n, x, &incx, y, &incy);
00122 }
00123 void swap_vector(int n, std::complex<double> *x, int incx,
00124                  std::complex<double> *y, int incy)
00125 {
00126   blas::zswap_(&n, x, &incx, y, &incy);
00127 }
00128 #else
00129 void swap_vector(int n, double *x, int incx, double *y, int incy)
00130 {
00131   for (int i = 0; i < n; i++)
00132     std::swap(x[i*incx], y[i*incy]);
00133 }
00134 void swap_vector(int n, std::complex<double> *x, int incx,
00135                  std::complex<double> *y, int incy)
00136 {
00137   for (int i = 0; i < n; i++)
00138     std::swap(x[i*incx], y[i*incy]);
00139 }
00140 #endif
00141 
00142 
00143 #if defined(HAVE_BLAS)
00144 void scal_vector(int n, double alpha, double *x)
00145 {
00146   int incr = 1;
00147   blas::dscal_(&n, &alpha, x, &incr);
00148 }
00149 void scal_vector(int n, std::complex<double> alpha, std::complex<double> *x)
00150 {
00151   int incr = 1;
00152   blas::zscal_(&n, &alpha, x, &incr);
00153 }
00154 #else
00155 void scal_vector(int n, double alpha, double *x)
00156 {
00157   if (alpha != 1.0) {
00158     for (int i = 0; i < n; ++i) {
00159       x[i] *= alpha;
00160     }
00161   }
00162 }
00163 void scal_vector(int n, std::complex<double> alpha, std::complex<double> *x)
00164 {
00165   if (alpha != std::complex<double>(1.0)) {
00166     for (int i = 0; i < n; ++i) {
00167       x[i] *= alpha;
00168     }
00169   }
00170 }
00171 #endif
00172 
00173 
00174 #if defined(HAVE_BLAS)
00175 void scal_vector(int n, double alpha, double *x, int incx)
00176 {
00177   blas::dscal_(&n, &alpha, x, &incx);
00178 }
00179 void scal_vector(int n, std::complex<double> alpha, std::complex<double> *x,
00180                  int incx)
00181 {
00182   blas::zscal_(&n, &alpha, x, &incx);
00183 }
00184 #else
00185 void scal_vector(int n, double alpha, double *x, int incx)
00186 {
00187   if (alpha != 1.0) {
00188     for (int i = 0; i < n; ++i) {
00189       x[i*incx] *= alpha;
00190     }
00191   }
00192 }
00193 void scal_vector(int n, std::complex<double> alpha, std::complex<double> *x,
00194                  int incx)
00195 {
00196   if (alpha != std::complex<double>(1.0)) {
00197     for (int i = 0; i < n; ++i) {
00198       x[i*incx] *= alpha;
00199     }
00200   }
00201 }
00202 #endif
00203 
00204 
00205 #if defined(HAVE_BLAS)
00206 void axpy_vector(int n, double alpha, const double *x, double *y)
00207 {
00208   int incr = 1;
00209   blas::daxpy_(&n, &alpha, x, &incr, y, &incr);
00210 }
00211 void axpy_vector(int n, std::complex<double> alpha,
00212                  const std::complex<double> *x, std::complex<double> *y)
00213 {
00214   int incr = 1;
00215   blas::zaxpy_(&n, &alpha, x, &incr, y, &incr);
00216 }
00217 #else
00218 void axpy_vector(int n, double alpha, const double *x, double *y)
00219 {
00220   if (alpha != 1.0) {
00221     for (int i = 0; i < n; ++i) {
00222       y[i] += alpha * x[i];
00223     }
00224   }
00225   else {
00226     for (int i = 0; i < n; ++i) {
00227       y[i] += x[i];
00228     }
00229   }
00230 }
00231 void axpy_vector(int n, std::complex<double> alpha,
00232                  const std::complex<double> *x, std::complex<double> *y)
00233 {
00234   if (alpha != std::complex<double>(1.0)) {
00235     for (int i = 0; i < n; ++i) {
00236       y[i] += alpha * x[i];
00237     }
00238   }
00239   else {
00240     for (int i = 0; i < n; ++i) {
00241       y[i] += x[i];
00242     }
00243   }
00244 }
00245 #endif
00246 
00247 
00248 #if defined(HAVE_BLAS)
00249 void axpy_vector(int n, double alpha, const double *x, int incx, double *y,
00250                  int incy)
00251 {
00252   blas::daxpy_(&n, &alpha, x, &incx, y, &incy);
00253 }
00254 void axpy_vector(int n, std::complex<double> alpha,
00255                  const std::complex<double> *x, int incx,
00256                  std::complex<double> *y, int incy)
00257 {
00258   blas::zaxpy_(&n, &alpha, x, &incx, y, &incy);
00259 }
00260 #else
00261 void axpy_vector(int n, double alpha, const double *x, int incx, double *y,
00262                  int incy)
00263 {
00264   if (alpha != 1.0) {
00265     for (int i = 0; i < n; ++i) {
00266       y[i*incy] += alpha * x[i*incx];
00267     }
00268   }
00269   else {
00270     for (int i = 0; i < n; ++i) {
00271       y[i*incy] += x[i*incx];
00272     }
00273   }
00274 }
00275 void axpy_vector(int n, std::complex<double> alpha,
00276                  const std::complex<double> *x, int incx,
00277                  std::complex<double> *y, int incy)
00278 {
00279   if (alpha != std::complex<double>(1.0)) {
00280     for (int i = 0; i < n; ++i) {
00281       y[i*incy] += alpha * x[i*incx];
00282     }
00283   }
00284   else {
00285     for (int i = 0; i < n; ++i) {
00286       y[i*incy] += x[i*incx];
00287     }
00288   }
00289 }
00290 #endif
00291 
00292 } // namespace itpp
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
SourceForge Logo

Generated on Sat Jul 9 2011 15:21:29 for IT++ by Doxygen 1.7.4