pointwiseop.h

Go to the documentation of this file.

/*
 MCL
 Copyright (c) 2012-18, Enzo De Sena
 All rights reserved.
 
 Authors: Enzo De Sena, enzodesena@gmail.com
 */

#ifndef MCL_POINTWISE_H
#define MCL_POINTWISE_H

#include <cassert>
#include "mcltypes.h"
#include <vector>
#include <limits>

namespace mcl {

template<class T> 
std::vector<T> Add(const std::vector<T>& vector_a,
                   const std::vector<T>& vector_b) noexcept {
  ASSERT(vector_a.size() == vector_b.size());
  
  std::vector<T> output((Int)vector_a.size());
  for (Int i=0; i<(Int)vector_a.size(); ++i) {
    output[i] = vector_a[i]+vector_b[i];
  }
  return output;
}
  
void Add(const Real* input_data_a,
                 const Real* input_data_b,
                 Int num_samples,
                 Real* output_data) noexcept;


template<>
inline std::vector<Real> Add(const std::vector<Real>& vector_a,
                             const std::vector<Real>& vector_b) noexcept {
  ASSERT(vector_a.size() == vector_b.size());
  
  std::vector<Real> output((Int)vector_a.size());
  Add(vector_a.data(), vector_b.data(), (Int)vector_a.size(),
      output.data());
  return output;
}
  
template<class T> 
std::vector<T> Opposite(const std::vector<T>& vector) noexcept {
  // Checking we are not dealing with unsigned types.
  // The assert below responds false to complex. TODO: fix this
  //ASSERT(std::numeric_limits<T>::is_signed);
  
  std::vector<T> output(vector.size());
  for (Int i=0; i<(Int)vector.size(); ++i) { output[i] = -vector[i]; }
  return output;
}
  
  
std::vector<Real> Inverse(const std::vector<Real>& vector) noexcept;

template<class T> 
std::vector<T> Subtract(const std::vector<T>& vector_a,
                        const std::vector<T>& vector_b) noexcept {
  return Add(vector_a, Opposite(vector_b));
}


template<class T> 
std::vector<T> Multiply(const std::vector<T>& vector_a,
                        const std::vector<T>& vector_b) noexcept {
  ASSERT(vector_a.size() == vector_b.size());
  
  std::vector<T> output((Int)vector_a.size());
  for (Int i=0; i<(Int)vector_a.size(); ++i) {
    output[i] = vector_a[i]*vector_b[i];
  }
  return output;
}

void Multiply(const Real* input_data_a, const Real* input_data_b,
              Int num_samples, Real* output_data) noexcept;
  
  
template<>
inline std::vector<Real> Multiply(const std::vector<Real>& vector_a,
                                  const std::vector<Real>& vector_b) noexcept {
  ASSERT(vector_a.size() == vector_b.size());
  
  std::vector<Real> output((Int)vector_a.size());
  Multiply(vector_a.data(), vector_b.data(), (Int)vector_a.size(),
           output.data());
  return output;
}
  
template<class T>
std::vector<T> Divide(const std::vector<T>& vector_a,
                      const std::vector<T>& vector_b) noexcept {
  ASSERT(vector_a.size() == vector_b.size());
  std::vector<T> output((Int)vector_a.size());
  for (Int i=0; i<(Int)vector_a.size(); ++i) {
    output[i] = vector_a[i]/vector_b[i];
  }
  return output;
}


template<class T>
std::vector<T> Exp(const std::vector<T>& vector) noexcept {
  Int n(vector.size());
  std::vector<T> output(vector.size());
  for (Int i=0; i<n; ++i) { output[i] = exp(vector[i]); }
  return output;
}
  
  
  
std::vector<Complex> Conj(const std::vector<Complex>& vector) noexcept;

std::vector<Complex>
ComplexVector(const std::vector<Real>& input) noexcept;

std::vector<Real> RealPart(const std::vector<Complex>& input) noexcept;

std::vector<Real> Imag(const std::vector<Complex>& input) noexcept;


std::vector<Real> Pow(const std::vector<Real>& vector,
                              Real exponent) noexcept;


std::vector<Real> Abs(const std::vector<Real>& input) noexcept;

std::vector<Real> Abs(const std::vector<Complex>& input) noexcept;

std::vector<Real> HalfWave(const std::vector<Real>& vector) noexcept;

std::vector<Real> Cos(const std::vector<Real>& vector) noexcept;

std::vector<Real> Sin(const std::vector<Real>& vector) noexcept;
  
std::vector<Real> Log(const std::vector<Real>& vector) noexcept;
  
std::vector<Real> Log10(const std::vector<Real>& vector) noexcept;
  
std::vector<Int> ConvertToInt(const std::vector<UInt>& vector) noexcept;
  
bool PointWiseOpTest();
  
} 
#endif