0

I am using python-3.x and I have tow loops first one which is number of runs (3 times) the second one to generate solutions (2 times)

what I want to do is: Collect the best solution from the second loop and append it to an array or list. The next run which is the first loop will run the second loop again, and it will collect the best solution from the second loop and append it to the same array or list. Which I will have two solutions in each run the total will be six solutions.

the problem is: I want to append the "best solution" to same index location for the next run.

in my case, the array will end up with a size of 6, but I want it to be a size of 3 where each index will include two values (best solution)

run 1: result inside the array: index 0 "The first best solution." index 1 "The second best solution."

run 2: result inside the array: index 0 "The first best solution." "The first best solution."

index 1 "The second best solution." "The second best solution."

If you take a look at the code and the result it will be more clear what I am trying to do? any advice or help you could provide would be much appreciated

import matplotlib.pyplot as plt
import math
import random
import numpy as np
import pylab      
from numpy import median
import os
import subprocess as sp

run = 3
best_solutions = [np.empty(0)]
del best_solutions[0]


# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 

for i in range (run):

    lower = 300
    upper  = 500

    number_of_solutions = 50
    generate_solutions = 2 

# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #    

    for ii in range (generate_solutions):     
        list_of_solutions = np.random.uniform(lower, upper, number_of_solutions)

        best_solutions.append(min(list_of_solutions))


        lower = lower - 30.4323434
        upper  = upper - 90.634555


    del (number_of_solutions) 
    del (lower)
2
  • the solution candidates that you are generating here are just numbers, so storing 6 values in memory is not a limitation. Have you considered storing all and then computing your "best" ones afterwards? Or is the np.random.uniform a stand-in for heavy computation? Commented Mar 7, 2018 at 15:21
  • the way you have written the desired outcome is rather difficult to understand. If you just gave numerical examples, and which ones you want to be in the final list it is likely very easy to solve Commented Mar 7, 2018 at 15:22

3 Answers 3

1

better work on nested list like [[1st best answer,1st best answer],[..,..]...] so you should define an other list in the second run . then append it to the result list . here's the modified code:

for i in range (run):
    lower = 300
    upper  = 500
    number_of_solutions = 50
    generate_solutions = 2 
    ####sub list 
    first_solution = []
    second_solution = []
    for ii in range (generate_solutions):     
        list_of_solutions = np.random.uniform(lower, upper, 
        number_of_solutions)
        #### append to the sub_list
        if ii == 1 :
            first_solution.append(min(list_of_solutions))
        if ii == 2 : 
            second_solution.append(min(list_of_solutions))
        lower = lower - 30.4323434
        upper  = upper - 90.634555
    del (number_of_solutions)
    del (lower)
#### append the sub_list to best_solutions after closing the loop
best_solution.append(fisrt_solution)
best_solution.append(second_solution)
Sign up to request clarification or add additional context in comments.

5 Comments

Could you please cleanup your answer. There are some indentation problem which are surely to mess up.
this a good way, but it, not the case that I want!!! I want to save all the values from loop 1 in the index 1 and all the values from loop 2 in the index 2 and so on.....
@benaoumouad , sorry but it, not the case that I want!!! could you please take a look at the next comments
ok , now i get it . you can check the code again i modified it . but know that according to what you are looking for ,the length of the list is 2 with each sublist's length is 3 @azeez
thank you @benaoumouad but the length of the list depends on the generate_solutions so (ii) can be 1 or more than 100, all of them are variables values.
0

to make it more clear....

if the (i) = 0 if the (ii) = 0 the min(solution) from this loop will be stored in best_solutions in the index 0 if the (ii) = 1 the min(solution) from this loop will be stored in best_solutions in the index 1 if the (ii) = 2 the min(solution) from this loop will be stored in best_solutions in the index 2 and so on......

second run: if the (i) = 1 if the (ii) = 0 the min(solution) from this loop will be stored in best_solutions in the index 0 if the (ii) = 1 the min(solution) from this loop will be stored in best_solutions in the index 1 if the (ii) = 2 the min(solution) from this loop will be stored in best_solutions in the index 2 and so on......

I hope this will clarify what I want to do!!

I tried to store them by index but it gives me an error:

for i in range (run):
lower = 300
upper  = 500
number_of_solutions = 50
generate_solutions = 2 
####sub list 
solution = []
for ii in range (generate_solutions):     
    list_of_solutions = np.random.uniform(lower, upper, number_of_solutions)
#### append to the sub_list
    solution.append(min(list_of_solutions))
    lower = lower - 30.4323434
    upper  = upper - 90.634555
#### append the sub_list to best_solutions
best_solutions[ii].append(solution[ii]) ############ here I tried to store them by index
del (number_of_solutions)
del (lower)

IndexError: list index out of range !!!????

Comments

0

Finally, I find the best way to solve my problem, this the final code that I wrote:

import random
import numpy as np

run = 3
best_solutions = [np.empty(0)]
best_sol_sorted = []
del best_solutions[0]
final_result = [np.empty(0)]
del final_result[0]

for i in range (run):
    lower = 300
    upper  = 500
    number_of_solutions = 50
    generate_solutions = 5

    ####sub list 
    solution = []

    for ii in range (generate_solutions):     
        list_of_solutions = np.random.uniform(lower, upper, number_of_solutions)

    #### append to the sub_list
        solution.append(min(list_of_solutions))
        lower = lower - 30.4323434
        upper  = upper - 90.634555
    best_solutions.append(solution)


for i in range(generate_solutions):
    for ii in range (run):
        best_sol_sorted.append(best_solutions[ii][i])
    final_result.append(best_sol_sorted)
    best_sol_sorted = []

where the last loop will do the job :) thanks for every one for giving ideas and advises

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.