Source code for pyFTS.partitioners.Grid

"""Even Length Grid Partitioner"""

import numpy as np
import math
import random as rnd
import functools, operator
from pyFTS.common import FuzzySet, Membership
from pyFTS.partitioners import partitioner


class GridPartitioner(partitioner.Partitioner):
    """Even Length Grid Partitioner"""

    def __init__(self, **kwargs):
        """
        Even Length Grid Partitioner
        """
        super(GridPartitioner, self).__init__(name="Grid", **kwargs)

    def build(self, data):
        sets = {}

        kwargs = {'type': self.type, 'variable': self.variable}

        dlen = self.max - self.min
        partlen = dlen / self.partitions

        count = 0
        for c in np.arange(self.min, self.max, partlen):
            _name = self.get_name(count)
            if self.membership_function == Membership.trimf:
                sets[_name] = FuzzySet.FuzzySet(_name, Membership.trimf, [c - partlen, c, c + partlen],c,**kwargs)
            elif self.membership_function == Membership.gaussmf:
                sets[_name] = FuzzySet.FuzzySet(_name, Membership.gaussmf, [c, partlen / 3], c,**kwargs)
            elif self.membership_function == Membership.trapmf:
                q = partlen / 2
                sets[_name] = FuzzySet.FuzzySet(_name, Membership.trapmf, [c - partlen, c - q, c + q, c + partlen], c,**kwargs)
            count += 1

        self.min = self.min - partlen

        return sets


class PreFixedGridPartitioner(GridPartitioner):
    """Prefixed UoD with Even Length Grid Partitioner"""

    def __init__(self, **kwargs):
        """
        Fixed UoD with Even Length Grid Partitioner
        """

        kwargs['preprocess'] = False

        super(GridPartitioner, self).__init__(name="Grid", **kwargs)

        self.max = kwargs.get('max', None)
        self.min = kwargs.get('min', None)

        if self.max is None or self.min is None:
            raise Exception("It is mandatory to inform the max and min parameters!")

        self.sets = self.build(None)

        self.partitions = len(self.sets)

        if self.ordered_sets is None and self.setnames is not None:
            self.ordered_sets = self.setnames[:len(self.sets)]
        else:
            self.ordered_sets = FuzzySet.set_ordered(self.sets)