Skip to content

part_period_heuristic.py

part_period_heuristic

dict_in = {'planningPeriod': 8, 'fixedCost': 10000, 'varCost': 1, 'roll': 4} module-attribute

demand = [0, 0, 6022, 6103, 3533, 4046, 3044, 3023, 4064, 9552, 3960, 5077, 4000, 4000, 3430, 300, 3400, 3440, 200, 3400, 9400, 4340, 3400, 300, 3040, 4000, 5000, 6500, 45454, 4443, 3244, 2334, 344, 3223, 2999, 4000, 4000, 4000, 3400, 3400, 3444, 5006, 4500, 400, 4500, 3400, 5400, 0, 0, 0, 4500, 4500, 4400, 555, 4540, 0, 0, 4555, 3000, 4555, 455, 3444, 4333, 2344, 4454, 4555, 3444] module-attribute

pp = PartPeriod() module-attribute

output = pp.run(dict_in, demand) module-attribute

PartPeriod

Source code in examples/lot_sizing/lot_optimizers/part_period_heuristic.py 
 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
class PartPeriod:
    def __init__(self):
        pass

    def run(self, dict_in, demand):
        # Füllen der Variablen aus Start_Dictionary
        dem = demand
        kf = dict_in["fixedCost"]
        kv = dict_in["varCost"]
        pp = len(dem)
        p = 0  # aktuelle Periode
        i = 0
        orders = [0 for i in range(pp)]
        orders1 = [0 for i in range(pp)]
        # Hilfsvariablen Kosten summieren
        cost = 0
        cost_i = 0
        cost_v = 0

        # testen ob "Null-Perioden am Anfang vorliegen
        while dem[p] == 0:
            orders1[p] = 0
            p = p + 1
            if p == pp:
                p = p - 1
                break
        i = p

        while p < pp:  # solange wie aktuelle Periode kleiner Anzahl PlanungsPerioden
            cost = cost + demand[p] * kv * (p - i)  # Formel Stückausgleichkostenverfahren
            if cost < kf:
                orders[p] += demand[p]
                lot = sum(orders) - sum(orders1)
                cost_v = cost
            else:
                cost_i = cost_v + cost_i
                orders1[i] = lot
                i = p
                p = p - 1
                cost = 0
                cost_v = 0
            p = p + 1
        orders1[i] = lot
        x = orders1.count(0)
        fix = (pp - x) * kf
        #    print(cost_i)
        #    print(fix)
        cost_i + fix + cost_v
        #   print("total cost: " + str(total_c))
        #    print(x)
        #    print(sum(orders1))
        return np.array(orders1)

__init__()

Source code in examples/lot_sizing/lot_optimizers/part_period_heuristic.py 
5
6
def __init__(self):
    pass

run(dict_in, demand)

Source code in examples/lot_sizing/lot_optimizers/part_period_heuristic.py 
 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
def run(self, dict_in, demand):
    # Füllen der Variablen aus Start_Dictionary
    dem = demand
    kf = dict_in["fixedCost"]
    kv = dict_in["varCost"]
    pp = len(dem)
    p = 0  # aktuelle Periode
    i = 0
    orders = [0 for i in range(pp)]
    orders1 = [0 for i in range(pp)]
    # Hilfsvariablen Kosten summieren
    cost = 0
    cost_i = 0
    cost_v = 0

    # testen ob "Null-Perioden am Anfang vorliegen
    while dem[p] == 0:
        orders1[p] = 0
        p = p + 1
        if p == pp:
            p = p - 1
            break
    i = p

    while p < pp:  # solange wie aktuelle Periode kleiner Anzahl PlanungsPerioden
        cost = cost + demand[p] * kv * (p - i)  # Formel Stückausgleichkostenverfahren
        if cost < kf:
            orders[p] += demand[p]
            lot = sum(orders) - sum(orders1)
            cost_v = cost
        else:
            cost_i = cost_v + cost_i
            orders1[i] = lot
            i = p
            p = p - 1
            cost = 0
            cost_v = 0
        p = p + 1
    orders1[i] = lot
    x = orders1.count(0)
    fix = (pp - x) * kf
    #    print(cost_i)
    #    print(fix)
    cost_i + fix + cost_v
    #   print("total cost: " + str(total_c))
    #    print(x)
    #    print(sum(orders1))
    return np.array(orders1)