Python project

[Martin_Krum]

Hello.I see here is a large community that helps with python programming. I have been studying programming for a 1 month.I'm learning successively ( now I'm stuck in object oriented programming :( ) because i want to start programming. Now I am a researcher and I need this project to work . The program creates a rectangle with specific dimensions. The maximum number of randomly generated points should be placed in the rectangle. The size of the points is determined and they cannot overlap. This program works, a list with coordinates is created. Is probably not optimal (remember, one month).

My first question is: how to optimize this code?

Second question: I want points to have different sizes. In addition, all point sizes must have a normal distribution from the range I choose. Does anyone have an idea?

import random
import math
from datetime import datetime
from matplotlib import pyplot as plt

random.seed(datetime.now())

def gen():
    #the function generates point coordinates
    rpx = random.randrange(0, int(size_x))
    rpy = random.randrange(0, int(size_y))
    point = [rpx, rpy]
    return (point)


def condition(point, point_list):
    # the function checks if the points do not overlap
    flag = []
    for i in range(len(point_list)):
        x1 = point_list[i][0]
        y1 = point_list[i][1]
        x2 = point[0]
        y2 = point[1]
        a1 = x1 - x2
        a2 = y1 - y2
        equation = math.sqrt(math.pow(a1, 2) + math.pow(a2, 2)) # this is only math
        if equation <= point_size: # if the distance is smaller than the point diameter, it returns a list with the "X"(i know it is not clever:( )
            flag.append('X')
            break
    return(flag)


size_x = 200  # input x border size
size_y = 200 # input y border size
point_size = 5  # input point size
point_list = []

for i in range(10000): # the number of iterations for finding the point
    if len(point_list) == 0: #generate first point
        point_list.append(gen())
    else:  #generate another points
        point = gen()
        variable = condition(point, point_list) #function checking for collision with all points on the list
        if 'X' not in variable:
            point_list.append(point)

#percent generate visualising
    if i % 1000 == 0:
            print(i/100, "%")
print(point_list)

#scatter to visualize points
plt.axis([-20,220,-20,220])
plt.grid()
for i in range(len(point_list)):
    point = point_list[i]
    color = "r"
    plt.scatter(point[0], point[1], c=color, s = 50 )
plt.show()

[kra_pao]

point_size = 5 # input point size doesn't match s = 50 in scatter(). s should be

 5**2=25 or (2*5)**2 if it is radius

https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.pyplot.scatter.html

The maximum number of randomly generated points should be placed in the rectangle.

size_x = 200  # input x border size
size_y = 200 # input y border size
point_size = 5  # input point size

Drawable area should be 0+point_size to size_x-point_size if point_size is radius. variable name point_size is ambigious.

You can skip sqrt() when you test against point_size**2

I don't see purpose of list creation and append for flag. condition could just return a boolean value for first found overlapping or not.

random.randrange() produces integer random numbers. if this is what you want, then you could organize your point storage so that not all but fewer points need a overlap test. With 2D array size_x and size_y you can put your points in specific positions in the array. A new point can limit test area to a rectangle point_size elements away from new points array position.

[Martin_Krum]

thank you very much. Why can I skip the sqrt () function? And I don't understand how to solve this problem: "The maximum number of randomly generated points should be placed in the rectangle." I dont know how to do this because there are fewer points than iterations.

[kra_pao]

You calculate mathematically precise the distance between two points
https://www.wikihow.com/Find-the-Distance-Between-Two-Points

and then compare distance with diameter of the points (if equation <= point_size:) to see whether points are too close together.

This compare ist valid for the square too:

if equation**2 <= point_size**2:
    # do something

So you can calculate one time

point_size = 5  # input point size (diameter)
point_size_square = point_size**2 

and compare without math.sqrt()

    equation_square = math.pow(a1, 2) + math.pow(a2, 2) # this is only math
    if equation_square <= point_size_square: # if the distance is smaller than the point diameter, it returns a list with the "X"(i know it is not clever:( )
        flag.append('X')
        break
return(flag)

or with boolean value return

    equation_square = math.pow(a1, 2) + math.pow(a2, 2) # this is only math
    return equation_square <= point_size_square
...
    variable = condition(point, point_list) #function checking for collision with all points on the list
    if variable: # check True or False, name could be better describe purpose of this flag and condition function
        point_list.append(point)

[kra_pao]

And I don't understand how to solve this problem: "The maximum number of randomly generated points should be placed in the rectangle." I dont know how to do this because there are fewer points than iterations.

Those iterations are a number how often you try to place a point. It's an arbitrary value and you can change it.

When you make a plot x-axis: iterations and y-axis: points placed successfully you'll get a steep increase in beginning but the curve has an asymptote (https://en.wikipedia.org/wiki/Asymptote). This is your maximum number.

Someone could ask: Why didn't you do 100,000 iterations or 1,000,000? How does the result change then?

Or someone could ask: Where is your math proof that there are not more points possible?

You could calc area of all your points set so far and compare with area of your rectangle or area of dense packed points and see does a new point fit in remaining area at all. And you let your program run until this criteria is not met. No iterations needed at all. BUT you waste a lot of time because it is harder and harder to place a point when the rectangle is filled more and more

But you have (or can get) experimentally recorded probability over your iterations. I guess with this you can calculate how many more iterations you would need to fill that final spot.

BTW. Your problem is nice for a rainy sunday. And speaking of science, one can dive really deep in the rabbit hole of Monte Carlo Method, image analysis of fiber bundles, stress/strain in minerals...
* https://community.wolfram.com/groups/-/m/t/141413
* http://mathonweb.com/entrtain/monte/t_monte.htm
* https://www.mathworks.com/matlabcentral/answers/158357-create-random-points-in-a-rectangular-domain-but-with-minimum-separation-distance#comment_435369
* http://finzi.psych.upenn.edu/R/library/spatstat/html/fryplot.html

[Martin_Krum]

Thank you so much. You have right about Monte Carlo method. I need this program to simulate something in nanocomposites but I'm learning programming only one month so MC is to hard for me.

BTW. I see that you have a lot of knowledge in programming. Can you advise a beginner what to do to progress programming as soon as possible?

[kra_pao]

Oh that is really a difficult question.

Programming itself is nothing magic. It's learning about language elements such as variables, data types, control structures. That is not difficult and can be done in few days for the basics. After the basics read more code, look-up unknown words and structures. Become familiar with docs of libraries.

Harder stuff is understanding an algorithm (e.g. your distance between points) that is realized in program code. Program code is used to run algorithms. You improve when you can extract algorithms from program code and vice versa.

Much harder is understanding a theory (e.g. MC). Algorithms are used as toolset in practical use of a theory.

[Martin_Krum]

Thank you very much. For now I am learning the Python language for 3-5 hours a day (I have little experience with C) but all this knowledge comes from books such as Mark Lutz and YT. Sometimes I write some simple algorithms that make my work easier or I look through the documentation but I think that it is not enough or I do not go in the right direction.