app-bholger/gfem/polyCoeff.h

Go to the documentation of this file.

#pragma once
#include "basics/typedefs.hh"
#include "convol.h"
#include <memory>
#include "stdio.h"
#include "assert.h"
#include "algorithm"

namespace concepts {

class PolyCoeff {
public:
  PolyCoeff(int n)
    : n(n)
  {
    coeffs = new Real[n];
  }
  
  ~PolyCoeff() {
    delete[] coeffs;
  }
  
  PolyCoeff(const PolyCoeff& other) : n(0), coeffs(NULL) {
    *this = other;
  }

  PolyCoeff& operator=(const PolyCoeff& other) {
    reserve(other.size());

    int min_n = std::min(n, other.size());

    for(int i = 0; i < min_n; ++i) {
      coeffs[i] = other.coeffs[i];
    }

    for(int i = min_n; i < n; ++i) {
      coeffs[i] = 0;
    }

    return *this;
  }

  Real eval(Real x) const {
    Real val = 0;

    for(int i=n; i--;) {
      val *= x;
      val += coeffs[i];
    }
    
    return val;
  }

  PolyCoeff& operator*=(Real coeff) {
    for(int i=0; i < size(); ++i) {
      coeffs[i] *= coeff;
    }

    return *this;
  }

  PolyCoeff& operator-=(const PolyCoeff& other) {
    assert(other.size() == size());

    for(int i=0; i < size(); ++i) {
      coeffs[i] -= other.coeffs[i];
    }

    return *this;
  }
  
  PolyCoeff operator*(const PolyCoeff& other) {
    return PolyCoeff(*conv(other));
  }

  int size() const {
    return n;
  }

  std::auto_ptr<PolyCoeff> mul(const PolyCoeff& other) {
    return conv(other);
  }
  
  std::auto_ptr<PolyCoeff> derivative() const {
    PolyCoeff* res = new PolyCoeff(n - 1);

    for(int i = 1; i < n; ++i) {
      res->coeffs[i-1] = coeffs[i] * i;
    }

    return std::auto_ptr<PolyCoeff>(res);
  }

  std::auto_ptr<PolyCoeff> conv(const PolyCoeff& other) {
    PolyCoeff* res = new PolyCoeff(n + other.n - 1);

    LinearConvolution(coeffs, other.coeffs, res->coeffs, n, other.n);

    return std::auto_ptr<PolyCoeff>(res);
  }

  void scalex(Real scale) {
    Real pow_scale = 1;
    for(int i=0; i < n; ++i) {
      coeffs[i] *= pow_scale;

      pow_scale *= scale;
    }
  }

  void scale(Real scale) {
    for(int i=0; i < n; ++i) {
      coeffs[i] *= scale;
    }
  }

  void resize(int n_new) {
    if(n == n_new)
      return;

    Real* coeff_new = new Real[n_new];

    int min_n = std::min(n, n_new);
    for(int i=0; i < min_n; ++i) {
      coeff_new[i] = coeffs[i];
    }

    for(int i=min_n; i < n_new; ++i) {
      coeff_new[i] = 0;
    }

    n = n_new;
    delete[] coeffs;
    coeffs = coeff_new;
  }

  void reserve(int n_new) {
    if(n < n_new) {
      Real* coeff_new = new Real[n_new];

      for(int i=0; i < n; ++i) {
        coeff_new[i] = coeffs[i];
      }
      n = n_new;
      delete[] coeffs;
      coeffs = coeff_new;
    }
  }

  void print(const char* name = "") const {
    printf("%s n=%d: ", name, n);

    for(int i=0; i < n; ++i) {
      //printf("%5.3f ", coeffs[i]);
      printf("%5.3f x^%d  ", getCoeff(i), i);
    }

    puts("");
  }

  void printMatlab(const char* name = "") const {
    printf("%s [", name);

    for(int i=0; i < n; ++i) {
      printf("%5.3f ", getCoeff(n-i-1));
    }

    puts("]");
  }

  inline Real& getCoeff(int i) {
    return coeffs[i];
  }

  inline Real getCoeff(int i) const {
    return coeffs[i];
  }

  inline Real& operator[](int i) {
    return getCoeff(i);
  }

  inline Real operator[](int i) const {
    return getCoeff(i);
  }

  Real* getCoeffs() {
    return coeffs;
  }

  const Real* getCoeffs() const {
    return coeffs;
  }

private:
  int n;
  Real* coeffs;
};

} // namespace