Coverage for robust\testing\t_equivalent_posynomials.py : 0%

from builtins import zip 

from builtins import range 

from gpkit import Variable 

import numpy as np 

import unittest 

from gpkit.tests.helpers import run_tests 

from robust.equivalent_posynomials import EquivalentPosynomials 

class TestEquivalentPosynomials(unittest.TestCase): 

def test_merge_intersected_lists(self): 

for _ in range(100): 

number_of_lists = int(10*np.random.random()) + 1 

list_of_lists = [] 

for l in range(number_of_lists): 

number_of_elements = int(5*np.random.random()) + 1 

list_of_lists.append([int(20*np.random.random()) for _ in range(number_of_elements)]) 

partition = EquivalentPosynomials.merge_intersected_lists(list_of_lists) 

for i in range(len(partition) - 1): 

self.assertTrue(all(not (set(partition[i]) & set(partition[j])) for j in range(i+1, len(partition)))) 

for from_list in list_of_lists: 

self.assertTrue(any(set(from_list) <= set(from_partition) for from_partition in partition)) 

def test_same_sign(self): 

for _ in range(20): 

number_of_elements = int(50*np.random.random()) + 1 

a = [int(20*np.random.random()) for _ in range(number_of_elements)] 

self.assertTrue(EquivalentPosynomials.same_sign(a)) 

a = [int(20*np.random.random()) - 19 for _ in range(number_of_elements)] 

self.assertTrue(EquivalentPosynomials.same_sign(a)) 

a = [int(20*np.random.random()) - 19 for _ in range(number_of_elements)] 

neg_flag = False 

for element in a: 

if element < 0: 

neg_flag = True 

break 

pos_flag = False 

for element in a: 

if element > 0: 

pos_flag = True 

break 

if neg_flag and pos_flag: 

self.assertFalse(EquivalentPosynomials.same_sign(a)) 

else: 

self.assertTrue(EquivalentPosynomials.same_sign(a)) 

def test_correlated_monomials(self): 

for _ in range(20): 

number_of_monomials = int(50*np.random.random())+1 

number_of_gp_variables = int(np.random.rand()*20) + 1 

number_of_uncertain_variables = int(np.random.rand()*5) + 1 

vector_to_choose_from = [0, 0, 0, 0, 0, 0, 0, 0, 1, -1] 

m = number_of_monomials*[1] 

p_uncertain_vars = [] 

correlations = [] 

dependent_theoretical_partition = [] 

# Generating random monomials 

for j in range(number_of_monomials): 

for i in range(number_of_gp_variables): 

x = Variable('x_%s' % i) 

m[j] *= x**(np.random.rand()*10 - 5) 

# Generating random uncertain variables to merge with monomials 

for i in range(number_of_uncertain_variables): 

u = Variable('u_%s' % i, np.random.random(), pr=100*np.random.random()) 

p_uncertain_vars.append(u.key) 

neg_pos_neutral_powers = [vector_to_choose_from[int(10*np.random.random())] for _ in range(number_of_monomials)] 

same_sign = EquivalentPosynomials.same_sign(neg_pos_neutral_powers) 

if not same_sign: 

related_monomials = [i for i in range(number_of_monomials) if neg_pos_neutral_powers[i] != 0] 

correlations.append(related_monomials) 

for j in range(number_of_monomials): 

m[j] *= u**(np.random.rand()*5*neg_pos_neutral_powers[j]) 

if neg_pos_neutral_powers[j] != 0: 

dependent_theoretical_partition.append(j) 

# Merging intersections of correlations gives the theoretical partition of monomials. 

theoretical_partition = EquivalentPosynomials.merge_intersected_lists(correlations) 

p = sum(m) 

equivalent_posynomial = EquivalentPosynomials(p, 0, False, False) 

equivalent_posynomial.main_p = p 

actual_partition = equivalent_posynomial.correlated_monomials() 

theoretical_posynomials = [] 

actual_posynomials = [] 

monomials = p.chop() 

for theo_list, act_list in zip(theoretical_partition, actual_partition): 

theoretical_posynomials.append(sum([m[i] for i in theo_list])) 

actual_posynomials.append(sum([monomials[j] for j in act_list])) 

self.assertSetEqual(set(actual_posynomials), set(theoretical_posynomials)) 

# dependent uncertainties 

temp = [] 

for part in theoretical_partition: 

temp += part 

theoretical_partition = list(set(dependent_theoretical_partition)) 

equivalent_posynomial = EquivalentPosynomials(p, 0, False, True) 

equivalent_posynomial.main_p = p 

actual_partition = equivalent_posynomial.correlated_monomials() 

theoretical_posynomials = [] 

actual_posynomials = [] 

theoretical_posynomials.append(sum([m[i] for i in theoretical_partition])) 

actual_posynomials.append(sum([monomials[j] for j in actual_partition[0]])) 

self.assertSetEqual(set(actual_posynomials), set(theoretical_posynomials)) 

def test_check_if_in_list_of_lists(self): 

for _ in range(20): 

number_of_lists = int(10*np.random.random()) + 1 

list_of_lists = [] 

number_of_elements = [] 

for l in range(number_of_lists): 

number_of_elements.append(int(5*np.random.random()) + 1) 

list_of_lists.append([int(200*np.random.random()) for _ in range(number_of_elements[l])]) 

element_list = int(number_of_lists*np.random.random()) 

element = list_of_lists[element_list][int(number_of_elements[element_list]*np.random.random())] 

non_element = int(200*np.random.random()) + 200 

self.assertTrue(EquivalentPosynomials.check_if_in_list_of_lists(element, list_of_lists)) 

self.assertFalse(EquivalentPosynomials.check_if_in_list_of_lists(non_element, list_of_lists)) 

TESTS = [TestEquivalentPosynomials] 

def test(): 

run_tests(TESTS) 

if __name__ == "__main__": 

test()