Example #1
0
def test_04():
    ln1 = make_line_eq(make_var('y'), make_const(2.0))
    ln2 = make_line_eq(make_var('y'), make_plus(make_prod(make_const(2.0),
                                                                            make_pwr('x', 1.0)),
                                                                        make_const(-6.0)))
    print(line_intersection(ln1, ln2))
    print(line_intersection(ln2, ln1))
Example #2
0
def test_09():  #y = 5; y = -x +6
    ln1 = make_line_eq(make_var('y'), make_const(5.0))
    ln2 = make_line_eq(
        make_var('y'),
        make_plus(make_prod(make_const(-1.0), make_pwr('x', 1.0)),
                  make_const(6.0)))
    print(line_intersection(ln1, ln2))
Example #3
0
def opt_prob_1c():
    f1 = lambda x, y: 3*x - 2*y


    #find corner points:
    ln1 = make_line_eq(make_plus(make_var('x'),make_var('y')), make_const(0.0))# x+y=0
    ln2 = make_line_eq(make_var('x'),make_var('y'))# x-y=0 => x=y
    ln3 = make_line_eq(make_plus(make_prod(make_const(-2.0), make_var('x')),make_prod(make_const(4.0), make_var('y'))), make_const(5.0))# -2x+4y=5


    p12 = line_intersection(ln1, ln2)
    p13 = line_intersection(ln1, ln3)

    p23 = line_intersection(ln2, ln3)


    possible_cps = [p12,p13,p23]

    corner_points = [pt for pt in possible_cps if -2*pt.get_x().get_val() + 4*pt.get_y().get_val() <= 5] # -2x+4y<=5
    corner_points = [pt for pt in corner_points if pt.get_x().get_val() + pt.get_y().get_val() >= 0] #x+y>=0
    corner_points = [pt for pt in corner_points if pt.get_x().get_val() - pt.get_y().get_val() <= 0] #x-y<=0

    # for pt in corner_points:
    #     print(pt.get_x().get_val(), pt.get_y().get_val())

    print '1c: ',maximize_obj_fun(f1, corner_points)
Example #4
0
def opt_prob_1a():
    f1 = lambda x, y: 2*x + y


    #find corner points:
    ln1 = make_line_eq(make_var('x'), make_const(1.0))
    ln2 = make_line_eq(make_var('y'), make_const(1.0))

    ln3 = make_line_eq(make_var('x'), make_const(5.0))
    ln4 = make_line_eq(make_var('y'), make_const(5.0))

    p12 = line_intersection(ln1, ln2)
    # p13 = line_intersection(ln1, ln3) #parallel lines
    p14 = line_intersection(ln1, ln4)

    p23 = line_intersection(ln2, ln3)
    # p24 = line_intersection(ln2, ln4) #parallel lines

    p34 = line_intersection(ln3, ln4)

    possible_cps = [p12,p14,p23,p34]

    corner_points = [pt for pt in possible_cps if pt.get_x().get_val() + pt.get_y().get_val() <= 6] #x+y <= 6

    # for pt in corner_points:
    #     print(pt.get_x().get_val(), pt.get_y().get_val())

    print '1a: ',maximize_obj_fun(f1, corner_points)
Example #5
0
def test_07():
    ln1 = make_line_eq(make_var('y'), make_plus(make_prod(make_const(-1.0/5.0),
                                                                                make_pwr('x', 1.0)),
                                                            make_const(10.0)))
    ln2 = make_line_eq(make_var('y'), make_plus(make_prod(make_const(1.0/5.0),
                                                                                make_pwr('x', 1.0)),
                                                            make_const(5.0)))
    print(line_intersection(ln1, ln2))
Example #6
0
def test_11():
    ln1 = make_line_eq(make_var('x'), make_const(1.0))
    ln2 = make_line_eq(make_var('y'), make_prod(make_const(0.5),
                                                                make_pwr('x', 1.0)))
    print(line_intersection(ln1, ln2))
    ln3 = make_line_eq(make_var('y'), make_plus(make_prod(make_const(-3.0/4),
                                                                            make_pwr('x', 1.0)),
                                                        make_const(3.0)))
    print(line_intersection(ln1, ln3))
    print(line_intersection(ln2, ln3))
Example #7
0
def test_05():  #y = x; y = 2x; y = 3x-10
    ln1 = make_line_eq(make_var('y'), make_pwr('x', 1.0))
    ln2 = make_line_eq(make_var('y'),
                       make_prod(make_const(2.0), make_pwr('x', 1.0)))
    ln3 = make_line_eq(
        make_var('y'),
        make_plus(make_prod(make_const(3.0), make_pwr('x', 1.0)),
                  make_const(-10.0)))
    print(get_line_coeffs(ln1))
    print(get_line_coeffs(ln2))
    print(get_line_coeffs(ln3))
Example #8
0
def test_05():
    ln1 = make_line_eq(make_var('y'), make_pwr('x', 1.0))
    ln2 = make_line_eq(make_var('y'), make_prod(make_const(2.0),
                                                                 make_pwr('x', 1.0)))
    ln3 = make_line_eq(make_var('y'), make_plus(make_prod(make_const(3.0),
                                                                            make_pwr('x', 1.0)),
                                                                    make_const(-10.0)))
    print(get_line_coeffs(ln1))
    print(get_line_coeffs(ln2))
    print(get_line_coeffs(ln3))

    print(line_intersection(ln1, ln2))
    print(line_intersection(ln2, ln3))
    print(line_intersection(ln1, ln3))
Example #9
0
def test_12():
    ln1 = make_line_eq(make_var('x'), make_const(0.0))
    ln2 = make_line_eq(make_var('y'), make_const(0.0))
    ln3 = make_line_eq(make_var('y'), make_plus(make_prod(make_const(-4.0/3),
                                                                            make_pwr('x', 1.0)),
                                                        make_const(160.0)))
    ln4 = make_line_eq(make_var('y'), make_plus(make_prod(make_const(-0.5),
                                                                            make_pwr('x', 1.0)),
                                                        make_const(120.0)))
    print(ln1)
    print(ln3)
    print(line_intersection(ln1, ln3))
    print(ln2)
    print(ln3)
    print(line_intersection(ln2, ln3))
    print(line_intersection(ln3, ln4))
Example #10
0
def opt_prob_1c():
    f1 = lambda x, y: 3 * x - 2 * y
    ln1 = make_line_eq(make_var('y'),
                       make_prod(make_const(-1.0), make_pwr('x', 1.0)))
    ln2 = make_line_eq(make_var('y'), make_pwr('x', 1.0))
    ln3 = make_line_eq(
        make_var('y'),
        make_plus(make_prod(make_const(1.0 / 2.0), make_pwr('x', 1.0)),
                  make_const(5.0 / 4.0)))

    cp_1 = line_intersection(ln1, ln2)  #y = -x; y = x
    cp_2 = line_intersection(ln1, ln3)
    cp_3 = line_intersection(ln2, ln3)

    corner_points = [cp_1, cp_2, cp_3]

    max_xy = maximize_obj_fun(f1, corner_points)
    max_val = f1(max_xy.get_x().get_val(), max_xy.get_y().get_val())
    print(max_xy, max_val)
Example #11
0
def opt_prob_1b():
    f1 = lambda x, y: x / 2 + y
    ln1 = make_line_eq(make_var('y'), make_const(2.0))
    ln2 = make_line_eq(make_var('x'), make_const(0.0))
    ln3 = make_line_eq(make_var('y'), make_pwr('x', 1.0))
    ln4 = make_line_eq(
        make_var('y'),
        make_plus(make_prod(make_const(-1.0), make_pwr('x', 1.0)),
                  make_const(6.0)))

    cp_1 = line_intersection(ln3, ln4)
    cp_2 = line_intersection(ln1, ln3)
    cp_3 = line_intersection(ln1, ln4)

    corner_points = [cp_1, cp_2, cp_3]

    min_xy = minimize_obj_fun(f1, corner_points)
    min_val = f1(min_xy.get_x().get_val(), min_xy.get_y().get_val())
    print(min_xy, min_val)
Example #12
0
def opt_prob_1a():
    f1 = lambda x, y: 2 * x + y
    ln1 = make_line_eq(make_var('x'), make_const(1.0))
    ln2 = make_line_eq(make_var('y'), make_const(1.0))
    ln3 = make_line_eq(make_var('x'), make_const(5.0))
    ln4 = make_line_eq(make_var('y'), make_const(5.0))
    ln5 = make_line_eq(
        make_var('y'),
        make_plus(make_prod(make_const(-1.0), make_pwr('x', 1.0)),
                  make_const(6.0)))

    cp_1 = line_intersection(ln1, ln5)
    cp_2 = line_intersection(ln1, ln2)
    cp_3 = line_intersection(ln4, ln5)

    corner_points = [cp_1, cp_2, cp_3]

    max_xy = maximize_obj_fun(f1, corner_points)
    max_val = f1(max_xy.get_x().get_val(), max_xy.get_y().get_val())
    print(max_xy, max_val)
Example #13
0
def opt_prob_1b():
    f1 = lambda x, y: x/2 + y

    #find corner points:
    ln1 = make_line_eq(make_var('x'), make_const(0.0))
    ln2 = make_line_eq(make_var('y'), make_const(2.0))

    ln3 = make_line_eq(make_var('x'), make_var('y'))#x=y
    ln4 = make_line_eq(make_plus(make_var('x'),make_var('y')), make_const(6.0))# x+y=6


    p12 = line_intersection(ln1, ln2)
    p13 = line_intersection(ln1, ln3)
    p14 = line_intersection(ln1, ln4)

    p23 = line_intersection(ln2, ln3)
    p24 = line_intersection(ln2, ln4)

    p34 = line_intersection(ln3, ln4)

    possible_cps = [p12,p13,p14,p23,p24,p34]

    # for pt in possible_cps:
    #     print pt

    corner_points = [pt for pt in possible_cps if pt.get_x().get_val() + pt.get_y().get_val() <= 6] #x+y <= 6
    corner_points = [pt for pt in corner_points if pt.get_x().get_val() >= pt.get_y().get_val()] #x>=y
    corner_points = [pt for pt in corner_points if pt.get_x().get_val() >= 0] #x>=0
    corner_points = [pt for pt in corner_points if pt.get_y().get_val() >= 2] #y>=2


    # for pt in corner_points:
    #     print(pt.get_x().get_val(), pt.get_y().get_val())

    print '1b: ',minimize_obj_fun(f1, corner_points)
Example #14
0
def linear_programming_prob1():
    f1 = lambda x, y: 5 * x + 4 * y
    ln1 = make_line_eq(
        make_var('y'),
        make_plus(make_prod(const(-4.0 / 3.0), make_pwr('x', 1.0)),
                  make_const(160)))
    ln2 = make_line_eq(
        make_var('y'),
        make_plus(make_prod(const(-3.0 / 6.0), make_pwr('x', 1.0)),
                  make_const(120)))

    ln3 = make_line_eq(make_var('x'), make_const(0.0))
    ln4 = make_line_eq(make_var('y'), make_const(0.0))

    cp_1 = line_intersection(ln2, ln3)
    cp_2 = line_intersection(ln1, ln2)
    cp_3 = line_intersection(ln1, ln4)

    corner_points = [cp_1, cp_2, cp_3]

    max_xy = maximize_obj_fun(f1, corner_points)
    max_val = f1(max_xy.get_x().get_val(), max_xy.get_y().get_val())
    print(max_xy, max_val)
Example #15
0
def test_03():  #y = -2; y = x +10
    ln1 = make_line_eq(make_var('y'), make_const(-2.0))
    ln2 = make_line_eq(make_var('y'),
                       make_plus(make_pwr('x', 1.0), make_const(10.0)))
    print(line_intersection(ln1, ln2))
    print(line_intersection(ln2, ln1))
Example #16
0
def test_01():
    ln1 = make_line_eq(make_var('y'), make_const(1.0))
    ln2 = make_line_eq(make_var('x'), make_const(1.0))
    assert is_const_line(ln1)
    assert is_const_line(ln2)
    print(line_intersection(ln1, ln2))
Example #17
0
from maker import make_line_eq
from maker import make_var, make_const, make_prod
from maker import make_pwr, make_plus
from maker import make_point2d
from const import const
from var import var
from prod import prod
from pwr import pwr
# from poly12 import is_pwr_1
from plus import plus
from tof import tof
from consts import is_const_line
import sys

### sample line equations
lneq1 = make_line_eq(make_var('y'), make_const(2))
lneq2 = make_line_eq(make_var('y'), make_var('x'))
lneq3 = make_line_eq(make_var('y'), make_var('y'))
lneq4 = make_line_eq(make_var('y'),
                     make_prod(make_const(2.0), make_pwr('x', 1.0)))
lneq5 = make_line_eq(make_var('y'),
                     make_prod(make_const(5.0), make_pwr('y', 1.0)))
lneq6 = make_line_eq(
    make_var('y'),
    make_plus(make_prod(make_const(5.0), make_pwr('x', 1.0)), make_const(4.0)))
lneq7 = make_line_eq(
    make_var('y'),
    make_plus(make_prod(make_const(5.0), make_pwr('y', 1.0)), make_const(4.0)))
lneq8 = make_line_eq(
    make_var('y'),
    make_plus(make_prod(make_const(3.0), make_pwr('x', 1.0)),
Example #18
0
from maker import make_point2d
from const import const
from var import var
from prod import prod
from pwr import pwr
# from poly12 import is_pwr_1
from plus import plus
from tof import tof
import sys
import numpy as np
'''
'''


### sample line equations
lneq1 = make_line_eq(make_var('y'),
                                    make_const(2))
lneq2 = make_line_eq(make_var('y'),
                                    make_var('x'))
lneq3 = make_line_eq(make_var('y'),
                                    make_var('y'))
lneq4 = make_line_eq(make_var('y'),
                                    make_prod(make_const(2.0),
                                                        make_pwr('x', 1.0)))
lneq5 = make_line_eq(make_var('y'),
                                    make_prod(make_const(5.0),
                                                        make_pwr('y', 1.0)))
lneq6 = make_line_eq(make_var('y'),
                                    make_plus(make_prod(make_const(5.0),
                                                                        make_pwr('x', 1.0)),
                                                    make_const(4.0)))