3. Description of two particles interacting and explaining the program in C++.

the thumbnail shows 1D implementation. 1,2,3,4,.... are the number of loops. in each loop I throw two numbers for each particle denoting their position and length. if the lines cross (star) I ignore I don't register the position( the round marks) or don't do anything with the lines. But if they don't cross then I have a counter that updates the number of times a hit happened in the particular position (the squared marks). then for each particle I have a counter that simply adds the lengths of this line to the previous total for each particle.

I do that (loops) a million, sometimes a 100 trillion times. then I normalize to the number of throws. the totals of the lines (normalized) are the energy. the numbers of hits for each positions is operated on to get the expectation values. normalized position hits are the probabilities that are similar to the ones we get from the "squaring" of the wavefunction. Without interaction the expectation value is the midpoint of the particle. But when interaction happens the expectation value moves. lets say to left in the left particle and right in the right particle. That denotes a repulsion. you can also get attraction with different logic. But more on the logic part later.

then the particles are moved to a different distance and the operation is repeated.

Now I explain the code in more detail.
see here.

1. define variables/types

2. set the particle widths (d0,d1) , which I interpret as the Compton wavelength, I assume lambda= h/mc the model shows (I will show why) that h=c , so lambda =1/m ,then I choose m to be in au hence if m=.0005485 then lambda=1822.8885 units of length on the axis/line . more on scale later.

3. set the interval (intr), that is used as a quantity to increase the distance between the particles after the calculation finished for certain distance.

4. start the mk loop that will increase the distance between the particle after each iteration.

5. based on mk value set the positions of the particles, zero out some of the variables need be. f1 is the number of hits for crossing f for not crossing. Zero out the arrays (S[],Sy[]),that hold the hits for each position on the axis/line.

6. next is the j loop the heart of the program, it iterates on the random throws

7. don't worry about these lines, not important

long r= rand();
double rndm=(double)r/((double)RAND_MAX);

8. calculate the start of the lines from inside of the particles and the length of the lines shooting to the other particl all based on random numbers.

9. use if ( st1+p1 + li1 > st0+ p - li) to check if lines crossed or not.

10. if not crossed update the position hit by incrementing the counter S[] for that position. add the random line to an accumulation counter (en). I do that for one of the particles only. the other will be similar.

While I said I don't do anything when lines crossed but in this program I do the same using Sy[], en1 just for information. I will talk more about it later.

11.go to 6

12. when done with j loop normalize the energy en to the numbers of throws accepted frf = (double)f/en; //energy of the particle

13. calculate the expectation value for the position array S[] -over the width of the particles.

edx = edx + (( n) * S[n]);

calculate how much expectation is offset from center of the particle

ex[mk] = (double)edx / ((double)f)- (0.5 * int(w*d1))+.5 ;

14. update all data in file for that separation.

15 . go to mk loop for new separation distance