utility.py

"""
##########################################################
### @Author Joe Krall      ###############################
### @copyright see below   ###############################

    This file is part of JMOO,
    Copyright Joe Krall, 2014.

    JMOO is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    JMOO is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with JMOO.  If not, see <http://www.gnu.org/licenses/>.
    
###                        ###############################
##########################################################
"""

"Brief notes"
"Bunch of often used functions"

import math

import numpy


def avg(list):
    return (float)(sum(list)) / (float)(len(list))


def sum(list):
    sum = 0;
    for i in list:
        sum += i;
    return sum


def median(list):
    return getPercentile(list, 50)


def spread(list):
    return getPercentile(list, 75) - getPercentile(list, 25)


def mul(list):
    sum = list[0]
    for i in list[1:]:
        sum *= i
    return sum


def var(list):
    mean = avg(list)
    squared_diffs = []
    for i in list:
        squared_diffs.append((i - mean) ** 2)
    return ((float)(sum(squared_diffs)) / (float)(len(list) - 1))


def avg2(list, index):
    "return the average of a particular column from an array of arrays"
    newlist = []
    for i in list:
        newlist.append(i[index])
    return avg(newlist)


def matrix_avg(matrix):
    vals = []
    averages = []

    # populate vals with empty frames
    for i in range(len(matrix[0])):
        vals.append([])

    # populate vals with matrix Data
    for i, row in enumerate(matrix):
        for j, col in enumerate(row):
            vals[j].append(col)

    # compute averages of each column
    for i, col in enumerate(vals):
        averages.append(avg(col))

    return averages


def matrix_var(matrix):
    vals = []
    variances = []

    # populate vals with empty frames
    for i in range(len(matrix[0])):
        vals.append([])

    # populate vals with matrix Data
    for i, row in enumerate(matrix):
        for j, col in enumerate(row):
            vals[j].append(col)

    # compute averages of each column
    for i, col in enumerate(vals):
        variances.append(var(col))

    return variances


def getPercentile(list, percentile):
    import math
    # sort the list
    list1 = sorted(list)

    k = (len(list1) - 1) * (percentile / 100.0)
    f = math.floor(k)
    c = math.ceil(k)
    if f == c:
        val = list1[int(k)]
    else:
        d0 = list1[int(f)] * (c - k)
        d1 = list1[int(c)] * (k - f)
        val = d0 + d1
    return val


def avg(list):
    return (float)(sum(list)) / (float)(len(list))


def sum(list):
    sum = 0;
    for i in list:
        sum += i;
    return sum


def var(list):
    mean = avg(list)
    squared_diffs = []
    for i in list:
        squared_diffs.append((i - mean) ** 2)
    return ((float)(sum(squared_diffs)) / (float)(len(list) - 1))


def dist(A, B):
    return sum([(a - b) ** 2 for a, b in zip(A, B)]) ** 0.5


def pretty_print(matrix):
    for row in matrix:
        s = ""
        for val in row:
            s += str('%15.3f' % (val)) + ", "
        print s


def getFront(problem, population):
    # fitnesses = [list(x) for x in set(tuple(x) for x in fitnesses)]

    myList = []
    for i, ind in enumerate(population):
        for d, decision in enumerate(problem.decisions):
            decision.value = ind.decisionValues[d]
        if True:  # not problem.evalConstraints():
            myList.append(population[i])

    # for i,pop in enumerate(population):
    #    print pop.decisionValues, sum(problem.evalConstraintOverages(pop.decisionValues)), problem.evalConstraints(pop.decisionValues)

    # Sort the list in either ascending or descending order of X
    myList = sorted(myList, key=lambda pop: pop.fitness.fitness)

    # Start the Pareto frontier with the first value in the sorted list
    p_front = []
    for pair in myList:
        if pair.valid and not problem.evalConstraints(pair.decisionValues):
            p_front = [pair]
            break

    # Loop through the sorted list
    for pair in myList[1:]:
        if pair.valid and pair.fitness.fitness[1] <= p_front[-1].fitness.fitness[1] and not problem.evalConstraints(
                pair.decisionValues):
            p_front.append(pair)

    area = 1

    return p_front, area


def pareto_frontier_multi(myArray):
    # fitnesses = [list(x) for x in set(tuple(x) for x in fitnesses)]

    # Sort on first dimension

    myArray = myArray[myArray[:, 0].argsort()]
    # Add first row to pareto_frontier
    pareto_frontier = myArray[0:1, :]
    # Test next row against the last row in pareto_frontier
    for row in myArray[1:, :]:
        if sum([row[x] >= pareto_frontier[-1][x]
                for x in range(len(row))]) == len(row):
            # If it is better on all features add the row to pareto_frontier
            pareto_frontier = numpy.concatenate((pareto_frontier, [row]))
    return pareto_frontier


def normalize(x, min, max):
    tmp = float((x - min)) / \
          (max - min + 0.000001)
    if tmp > 1:
        return 1
    elif tmp < 0:
        return 0
    else:
        return tmp


def loss(x1, x2, mins=None, maxs=None):
    # normalize if mins and maxs are given
    if mins and maxs:
        x1 = [normalize(x, mins[i], maxs[i]) for i, x in enumerate(x1)]
        x2 = [normalize(x, mins[i], maxs[i]) for i, x in enumerate(x2)]

    o = min(len(x1), len(x2))  # len of x1 and x2 should be equal
    return sum([math.exp((x2i - x1i) / o) for x1i, x2i in zip(x1, x2)]) / o


def loss2(x1, pop, mins=None, maxs=None, weights=None):  # removal of pop-x1 vs pop

    k = len(weights)
    norms = [(min, max) for min, max in zip(mins, maxs)]
    # Calculate the loss in quality of removing fit1 from the population
    F = []
    for X2 in pop:
        if not X2[0] == '?':
            F.append(-k / (sum(
                [-math.exp(-w * (normalize(p2, n[0], n[1]) - normalize(p1, n[0], n[1])) / k) for w, p1, p2, n in
                 zip(weights, x1, X2, norms)])))
    F1 = sum(F)
    return F1


def cdom(x1, x2, mins=None, maxs=None):
    return loss(x1, x2, mins, maxs) / loss(x2, x1, mins, maxs)


def spacing(dataset, distance_m):
    dim = len(dataset[0])
    # d_ = []
    # for i, fit_i in enumerate(dataset):
    #     fma = []
    #     for j, fit_j in enumerate(dataset):
    #         if not i == j:
    #             fma.append(sum([abs(fit_i[k] - fit_j[k]) for k in range(dim)]))
    #     d_.append(min(fma))
    d_bar = avg(distance_m)
    ssm = ((1 / float(len(dataset) - 1)) * sum([(d_bar - d_i) ** 2 for d_i in distance_m])) ** 0.5
    return ssm


def callrdivdemo(eraCollector):
    keylist = eraCollector.keys()
    variant = len(keylist)
    rdivarray = []
    for y in xrange(variant):
        temp = eraCollector[keylist[y]]
        temp.insert(0, str(keylist[y]))
        rdivarray.append(temp)
    rdivDemo(rdivarray)


"""
def losstest():
x1 = [0.1, 0.1, 0.1, 0.1]
x2 = [9, 6, 5, 4]
x3 = [0.8, 0.6, 0.5, 0.4]
x4 = [8, 6, 5, 4]
x5 = [0.4, 0.5, 0.4, 0.3]
x6 = [4, 5, 4, 3]
"""