shape_hyperbolic.hpp

Go to the documentation of this file.

#pragma once

#include <cmath>
#include <string>
#include <sstream>

#include "../../types.hpp"

#include "shape_base.hpp"


namespace waveblocks {
    namespace wavepackets {
        namespace shapes {
            template<dim_t D>
            class HyperbolicCutShape : public AbstractShape<D>
            {
            private:
                int S_;

            public:
                HyperbolicCutShape(int S) : S_(S) {}

                virtual int bbox(dim_t axis) const override
                {
                    (void)(axis); // unused
                    return S_ - 1;
                }

                virtual int limit(int const* base_node, dim_t axis) const override
                {
                    double s = S_;

                    for (dim_t i = 0; i < D; i++) {
                        if (i != axis) {
                            s /= 1 + base_node[i];
                        }
                    }

                    return (int)s - 1;
                }

                virtual void print(std::ostream & out) const override
                {
                    out << "HyperbolicCutShape{sparsity: " << S_ << "}";
                }
            };

            template<dim_t D>
            class LimitedHyperbolicCutShape : public AbstractShape<D>
            {
            private:
                int S_;
                std::array<int,D> limits_;

            public:
                LimitedHyperbolicCutShape(int S, const std::array<int,D> &limits)
                    : S_(S)
                    , limits_(limits)
                { }

                LimitedHyperbolicCutShape(int S, int size)
                    : S_(S)
                {
                    for (std::size_t d = 0; d < D; d++)
                        limits_[d] = size;
                }

                LimitedHyperbolicCutShape(int S, std::initializer_list<int> list)
                    : S_(S)
                {
                    int deflt = 0;
                    std::size_t i = 0;
                    for (int e : list) {
                        limits_[i++] = deflt = e;
                    }
                    //fill remaining elements with last value of initializer list
                    while (i < D) {
                        limits_[i++] = deflt;
                    }
                }

                virtual int bbox(dim_t axis) const override
                {
                    return std::min( limits_[axis]-1, S_ - 1);
                }

                virtual int limit(int const* base_node, dim_t axis) const override
                {
                    double s = S_;

                    for (dim_t i = 0; i < D; i++) {
                        if (i != axis) {
                            if (base_node[i] >= limits_[i])
                                return -1;
                            else
                                s /= 1 + base_node[i];
                        }
                    }

                    return std::min((int)limits_[axis]-1, (int)s - 1);
                }

                virtual void print(std::ostream & out) const override
                {
                    out << "LimitedHyperbolicCutShape{ sparsity: " << S_ << ", limits (exclusive): [";
                    for (dim_t i = 0; i < D-1; i++) {
                        out << limits_[i] << ",";
                    }
                    out << limits_[D-1] << "]";
                    out << "}";
                }
            };
        }
    }
}