UniqueCoefficientContainer.hpp

Go to the documentation of this file.

#ifndef UNIQUE_HPP
#define UNIQUE_HPP

#include <cmath>
#include <iostream>
#include <cstdlib>
#include <cassert>

class Node {
  Node *left;
  Node *right;
  double x;
  unsigned short idx;
public:
  Node () {
    left = NULL;
    right = NULL;
    x    = 0;
    idx  = 0;
  }
  Node(double x, unsigned short idx) {
    this->x = x;
    this->idx=idx;
    left = NULL;
    right = NULL;
  }
  Node(const Node &n) {
    x    = n.x;
    idx  = n.idx;
    left = n.left;
    right= n.right;
  }
  Node &operator=(const Node &n) {
    x = n.x;
    idx=n.idx;
    left = n.left;
    right = n.right;
    return *this;
  }
  bool operator<(const Node &n) const {
    return x < n.x;
  }
  bool operator>(const Node &n) const {
    return x > n.x;
  }
  bool operator==(const Node &n) const {
    return x == n.x;
  }
  unsigned short getIndex() const {
    return idx;
  }
  double getValue() const {
    return x;
  }

  unsigned short setLeft(const Node &node) {
    if (left == NULL) {
      left = new Node(node);
      return node.getIndex();
    }
    
    if (node==*left) {
      return left->getIndex();
    } else if (node < *left) {
      return left->setLeft(node);
    } else { // (*left < node)
      return left->setRight(node);
    }

  }//setLeft()

  unsigned short setRight(const Node &node) {
    if (right == NULL) {
      right = new Node(node);
      return node.getIndex();
    } 
    if (node == *right) {
      return right->getIndex();
    } else if (node < *right) {
      return right->setLeft(node);
    } else { // (*right < node)
      return right->setRight(node);
    }
  }//setRight()

  ~Node() {
    if (left != NULL)  {
      delete left;
      left = NULL;
    }
    if (right!= NULL) {
      delete right;
      right= NULL;
    }
  }
};


class UniqueCoefficientContainer {
  double *coeff; 
  unsigned short size; 
  Node root_node;

  unsigned short insert(const Node &node) {
    if (node.getIndex() == 0) {
      // set the root node
      root_node = node;
      coeff[0]  = node.getValue();
      size = 1;
      return 0;
    }

    unsigned short idx=0;
    if (node == root_node) {
      return 0;
    }

    if (node < root_node) {
      idx = root_node.setLeft(node);
      if (idx == size) { // a new node is added to the tree
        coeff[size] = node.getValue();
        size = size + 1;
      }
    }
    
    if (root_node < node) {
      idx = root_node.setRight(node);
      if (idx == size) { // a new node is added to the tree
        coeff[size] = node.getValue();
        size = size + 1;
      } 
    }

    return idx;
  }//insert
public:
  UniqueCoefficientContainer() {
    int n = std::pow(2,16);
    coeff = new double[n];
    size = 0;
  }

  unsigned short insert(double x) {
    assert(size <= 65536);
    Node node(x, size);
    unsigned short idx = insert(node);
    return idx;
  }

  unsigned short insert_deprecated(double x) {
    assert(size <= 65536);

    unsigned short idx;
    for (idx = 0; idx < size; idx++) {
      if (coeff[idx] == x)
        return idx;
    }
    coeff[size] = x;
    size++;
    return size;
  }

  const double * getHandle() {
    return coeff;
  }

  void print() const {
    std::cout << "Coefficient container : " << std::endl;
    for (unsigned i=0; i<size; i++) 
      std::cout << coeff[i] << std::endl;
  }

  ~UniqueCoefficientContainer() {
    delete [] coeff;
    size = 0;
  }
};

#endif