linear-programming/orderedSearchPure.py at master · feisuxiaozhu/linear-programming · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
from numpy import *
from itertools import *
import math
import scipy.io

def findLeadingZero(x): #find the number of leading zeros if x is pure form
    counter=0
    for i in range(len(x)):
        if x[i] != '1':
            counter+=1
        else:
            break
    return counter

def generatePureInputs(N):
# return all pure inputs of length N. If N = 3, return [001,011]
    res=[]
    for i in range(1,N):
        tail = "1" * i
        head = "0" * (N-i)
        temp = head+tail
        res.append(temp)
    return res

def generateF(N):
    inputs = generatePureInputs(N)
    length = len(inputs)
    f = zeros(2*length)
    i = 0
    for x in inputs:
        index = findLeadingZero(x)
        f[2*i] = pow(-1, index)
        f[2*i+1] = pow(-1, index) * (-1)
        i += 1
    f = -f
    return f

def generatelb(N):
    lb = zeros(2*(N-1))
    return lb

def generateA(N):
    A = ones(2*(N-1))
    return A

def generateb():
    return 1.

def AeqRowHelper(degree, N):
    if degree == 0:
        temp = []
        res = zeros(2*(N-1))
        for i in range(len(res)):
            if i%2 == 0:
                res[i] = 1
            else:
                res[i] = -1
        temp.append(res)
        return temp
    s = list(range(N))
    powerS = list(combinations(s, degree))
    print(powerS)
    res = []
    inputs = generatePureInputs(N)
    for xIndices in powerS:
        temp = zeros(2*(N-1))
        for i in range(N-1):
            x=inputs[i]
            temp[2*i] = 1
            temp[2*i+1] = -1
            for xIndex in xIndices:
                bit = int(x[xIndex])
                temp[2*i] *= -1*pow(-1,bit)
                temp[2*i+1] *= -1*pow(-1,bit)
        res.append(temp)
    return res

def generateAeq(d,N):
    res = []
    for degree in range(d+1):
        temp = AeqRowHelper(degree, N)
        for row in temp:
            res.append(row)
    return res

def nCr(n,r):
    f = math.factorial
    return f(n) / f(r) / f(n-r)

def generateBeq(d,N):
    temp=[]
    res = 1
    for i in range(1,d+1):
        res += nCr(N,i)
    res = int(res)
    for j in range(res):
        temp.append(0.)
    return temp

def generateBeqV2(Aeq):
    temp = []
    for i in range(len(Aeq)):
        temp.append(0.)
    return temp

N=4
d=1

f = generateF(N)
A = generateA(N)
b = generateb()
lb = generatelb(N)
Aeq = generateAeq(d,N)
beq = generateBeqV2(Aeq)
scipy.io.savemat('./pure.mat', mdict={'f': f, 'A':A, 'b':b, 'lb':lb, 'Aeq':Aeq,'beq':beq})