utils.h

Go to the documentation of this file.

 
#pragma once
#include <bitset>
#include <cmath>
#include <cstdint>
#include <cstring>
#include <string>
#include <vector>
 
namespace gymbo {
 
inline bool is_integer(float x) { return std::floor(x) == x; }
 
inline uint32_t FloatToWord(float val) {
    uint32_t word;
    std::memcpy(&word, &val, sizeof(val));
    return word;
}
 
inline float wordToFloat(uint32_t word) {
    float val;
    std::memcpy(&val, &word, sizeof(word));
    return val;
}
 
inline int wordToInt(uint32_t word) { return static_cast<int>(word); }
 
inline int wordToSignedInt(uint32_t word) {
    if (word & 0x80000000) {
        return -static_cast<int>(wordToSignedInt(~word + 1));
    } else {
        return static_cast<int>(word);
    }
}
 
inline bool wordToBool(uint32_t word) { return word != 0; }
 
inline uint32_t boolToWord(bool value) { return value ? 1 : 0; }
 
inline uint32_t twosComplement(uint32_t i) { return 1 + ~i; }
 
inline bool isNegative(uint32_t word) { return (word & 0x80000000) != 0; }
 
inline std::string valName(int i) { return "val_" + std::to_string(i); }
 
template <typename T>
class LLNode {
   public:
    T data;        
    LLNode *next;  
    LLNode *prev;  
 
    LLNode(T data) : data(data), next(NULL), prev(NULL) {}
};
 
template <typename T>
class Linkedlist {
   public:
    LLNode<T>
        *ghost;  
    LLNode<T> *head;  
    LLNode<T> *tail;  
 
    Linkedlist() : ghost(NULL), head(NULL), tail(NULL) {}
 
    uint32_t len() {
        LLNode<T> *tmp = head;
        uint32_t cnt = 0;
        while (tmp != NULL) {
            cnt++;
            tmp = tmp->next;
        }
        return cnt;
    }
 
    void push(T data) {
        // Create the new Node.
        LLNode<T> *newNode = new LLNode<T>(data);
 
        // Assign to head
        if (head == NULL) {
            head = newNode;
            tail = head;
            return;
        }
 
        tail->next = newNode;
        newNode->prev = tail;
        tail = newNode;
    }
 
    T *back() {
        if (tail == NULL) {
            fprintf(stderr, "Warning... tail of linked-list is null\n");
        }
        return &(tail->data);
    }
 
    void pop() {
        if (tail == NULL) {
            fprintf(stderr, "Warning... tail is NULL when trying to pop\n");
            return;
        }
 
        LLNode<T> *current_tail = tail;
        tail = tail->prev;
        if (tail != NULL) {
            tail->next = NULL;
        }
 
        if (current_tail == head) {
            head = NULL;
        }
 
        if (ghost == NULL) {
            ghost = current_tail;
        } else {
            ghost->next = current_tail;
            current_tail->prev = ghost;
            ghost = tail;
        }
    }
};
 
inline std::vector<std::vector<int>> cartesianProduct(
    const std::vector<std::vector<int>> &vectors) {
    std::vector<std::vector<int>> result;
 
    if (vectors.size() == 0) {
        return result;
    }
 
    for (int v : vectors[0]) {
        std::vector<int> tmp = {v};
        result.emplace_back(tmp);
    }
 
    for (int i = 1; i < vectors.size(); ++i) {
        std::vector<std::vector<int>> tempResult;
        for (const auto &element1 : result) {
            for (const auto &element2 : vectors[i]) {
                std::vector<int> tempElement = element1;
                tempElement.push_back(element2);
                tempResult.push_back(tempElement);
            }
        }
        result = tempResult;
    }
 
    return result;
}
};  // namespace gymbo