Python File:

https://www.dropbox.com/s/5q3x6cdqbk3sh5i/First%20Iteration%3B%20NP%20Calculator.py?dl=0

Text File:

https://www.dropbox.com/s/lu3ufxs1epf51o5/NP%20Formulas.txt?dl=0

—

**Download Python, or click the links so that you can read this with ease**

If you click the Python link it will color code everything

This makes it very easy to understand.

**
****Please use the downloaded text file rather than copying from this site …**

as the code has been truncated to allow easier reading

Improved Code For Universal Laws:

(Images Added To Bottom For Easy Reading; Color Coded, With Detailed Explanation.)

# Python code for Ease Point calculations and Large Body Orbits
### Updated 12/17/18 to add electron count maximums using 1/2 subdivides
### Updated 1/1/19 to add electron shell ratios using 1/2 subdivides
### Updated 1/1/19 to improve previous ratios for L1-L3, along with initial values
#Please see www.arisopus.com if you have any questions on syncopation
or wave relationships.
#------------ #Begin Code.# ------------#
input("Python code for Ease Point (formerly Lagrange) calculations,
Atomic Relationships and Large Body Orbits\n"
"### Updated 12/17/18 to add electron count maximums using 1/2 subdivides\n"
"### Updated 1/1/19 to add electron shell ratios using 1/2 subdivides\n"
"### Updated 1/1/19 to improve previous ratios for L1-L3
along with initial values\n\n\n"
"Please see http://www.arisopus.com if you have any questions on syncopation
or wave relationships.\n\n\n"
"Press Enter To Continue ...\n\n\n"
"# Input = Total number of points\n"
"# N = Number of points traveled\n"
"# NP = Number of points remaining\n\n"
"When calculating ease points, please use diameter from nucleus to first body\n"
"Enter the radius from nucleus for n\n"
"Enter 0 for np if there is no third body to follow\n\n"
"---\n\n"
"Helpful Measurements:\n\n"
"Diameter Sun to Earth: 300000000 km\n"
"Radius Sun to Earth: 150000000 km\n\n"
"Diameter Earth to Moon: 750000 km\n"
"Radius Earth to Moon: 375000 km\n")
IN = float(input("Enter Input: "))
N = float(input("Enter N: "))
NP = float(input("Enter NP: "))
IN = 0.5 if IN == 0 else IN
N = 0.5 if N == 0 else N
NP = 0.5 if NP == 0 else NP
input = IN
n = N
np = NP
# - Used to allow lowercase letters in code. Ensures no division by zero errors occur.
# input = total number of points
# n = number of points traveled
# np = number of points remaining
# ----------------- #
# Read Ratios #
# ----------------- #
sub_divide_half = 2
'Example (Fourth, Half): 10 / 4 / 5 / 5 = 1.0; 100 / 1.0 = 100' \
#or see it as .01; 10 / .01 = 100
'Example (Third, Half): 10 / 3 / 5 / 5 = 1.33 repeating; 100
/ 1.33 repeating = 75' \
#or see it as .133 repeating; 10 / .133 repeating = 75
' This tells us that universal laws follow 1/2, 1/4, 1/3, 4/8 ratios'
' Add both maximum shell ratios (+,-) together and you get 1, 1/2, 2/3, 1'
# That is 2, 8, 18, 32, 32, 18, 8, 2 - Or the function of a sine wave
sub_divide_half_example = 1/2 #; = 2
sub_divide_third_example = 6 / 4 / (1/2) #; = 3
# 1 and 1/3 is one quarter away from a full fourth
# 100 - 25 (1/4) / 3 (33.33) = 25
' #4/8 fits into this, because it can equal both one half of 4, and one half of 3'
' #It can also be seen as a function of 1/4'
# 2/6 equals 1/2 of 1/3 ... or 1/3 of 1/4
# 1/4 equals 2/8 and 1/8 or 3/8 is halfway between fourths
' This shows that 3rds grow in 4th intervals, and require one full fraction over
' the whole to syncopate' \
' This is the same as saying what is 9 (3*3) broken into 4 inside a bucket of 10 (100)'
' Or 100 / 3 / two separate 50s'
# Sixths can give you halves, thirds and quarters. Quarters can give you halves and
wholes. They scale up and down.
#---------------------#
# - There is no need to use any other ratios. They all work with each other.
# - It is helpful to learn them.
# - Knowing all fractional scales within another up to 100 will set your mind to know
this all by heart
# (intuition)
# - These patterns are found in everything from atoms, to galaxies ...
# to behavioral patterns, brain waves and DNA.
# --------------- #
# System Ratios #
# --------------- #
#init = input / sub_divide_half
#baselimiter = init / sub_divide_half
#sub_divide_from_ceiling = baselimiter / input
#ds_syncopation_4_5 = input / sub_divide_from_ceiling / sub_divide_half
#syncopation_point = sub_divide_from_ceiling * ds_syncopation_4_5 / sub_divide_half
#shell_half = init / baselimiter
#whole_ratio_combine = baselimiter + baselimiter / syncopation_point
#whole_ratio = whole_ratio_combine - syncopation_point
' Please note that all current binary formats are incapable of handling ...
perfect circle ratios;' \
' Because of this I am required to write a new binary decimal system which can
' Doing so should prove we can get the sub half using only inputs,
just like I did with the shell ratios' \
# This could take me months, as I have never coded binary formats.
# For now, you may see an occasional rounding error due to the way
binary bases have been written.
#--------------------#---------------------#---------------------#--------------------#
# Initial Ratios
init = input / sub_divide_half
init = 0.5 if init == 0 else init
# - This gives you half of the input, or the halfway point between two planets or orbits
# IE:
# (6); 12 / 2 = 6
#--------------------#---------------------#---------------------#--------------------#
# Initial Ratios
baselimiter = init / sub_divide_half
baselimiter = 0.5 if baselimiter == 0 else baselimiter
# - This uses the input combined with the subdivide.
It turns the system into a ratio of fourths through 8.
#IE:
# (3); 6 / 2 = 3
#--------------------#---------------------#---------------------#--------------------#
# Subdivides
sub_divide_from_ceiling = baselimiter / input
sub_divide_from_ceiling = 0.5 if sub_divide_from_ceiling == 0
else sub_divide_from_ceiling
#- This uses the baselimiter to pull the input ratios in the form of a decimal
IE: 1/4 (.25).
#- This always equals .25
#- That information will become much more meaningful when binary can hold ratios
to obtain a subdivide ..
#- ... Which uses all inputs ( Input / N / NP )
#--------------------#---------------------#---------------------#--------------------#
# Subdivides
ds_syncopation_4_5 = input / sub_divide_from_ceiling / sub_divide_half
#IE:
# (24); 6 / 3 * 12 = 24
#
# or
#
# (24); 12 / .25 / 2 = 24 ***** Preferable
ds_syncopation_4_5 = 0.5 if ds_syncopation_4_5 == 0 else ds_syncopation_4_5
' This doubles the system by dividing the input in half twice (4).
It creates 5 points through 4 spacings.'
' It acts as either a subdivide,
or adds a new system next to what is entered as the input'
#- In other words, it takes the nucleus and first following point,
and gives an opposite point, plus a new point
#- Or it breaks it all down into 4ths.
#- The input is typically a diameter which houses 2 radius'
#- Which leads to the next nucleus; fourths need halves or sixths to grow.
Thirds need two fourths or sixths.
# With thirds, you then get 15/100ths, which lead to 6.66 and allow a new syncopation
# or continue to 5/100ths until and you can then refill with halves/quarters
# Need to write a ds which includes 6th point for new group functions.
# DS means dual system; to be used for later cascading calculations/combinations.
#--------------------#---------------------#---------------------#--------------------#
# Subdivides
syncopation_point = sub_divide_from_ceiling * ds_syncopation_4_5 / sub_divide_half
syncopation_point = 0.5 if syncopation_point == 0 else syncopation_point
#- This is the syncopation point, or point which will be centered in the
forthcoming wave as shells ...
#- ... or orbits fill, or so long as the ratios are satisfied to reach this point.
If the ratios do not match ...
#- ... you will need to subdivide into a new ratio which does
' It does this as a matter of 4ths, where syncopation is at halfway between
the nucleus and orbital' \
' sync * 2 is where a second system can begin' \
' sync * 3 is where you reach a third ratio; it would either break, divide,
or require a satisfying addition' \
# This is because we are thinking primarily in fourths.
This can also be done in thirds
# Thirds require closed systems, and are found more in biology than planets
# Fourths can fill thirds, and thirds don't require fourths
but we need to keep a balance
# We will find more third type systems as a matter of confined spaces.
# It is my own theory that fourths are generally going to be found in
planetary systems and open space
#--------------------#---------------------#---------------------#--------------------#
# Halves
shell_half = init / baselimiter
shell_half = 0.5 if shell_half == 0 else shell_half
# - This always gives you 2. There are many ways to do this.
#--------------------#---------------------#---------------------#--------------------#
# Additives
whole_ratio_combine = baselimiter + baselimiter / syncopation_point
whole_ratio_combine = 0.5 if whole_ratio_combine == 0 else whole_ratio_combine
# - This will always add one to the system ratio.
It will be used to calculate movements over time
#--------------------#---------------------#---------------------#--------------------#
# Additives
whole_ratio = whole_ratio_combine - syncopation_point
whole_ratio = 0.5 if whole_ratio == 0 else whole_ratio
'Another way to picture this is ((Input + Input + n + n + np) / n)
- ((Input + Input + n + np) / n )'
#---------------------#
# ------------------#
# Shell Ratios #
# ------------------#
#max_electron_count = init / ((np/sub_divide_half) * (np/sub_divide_half)) * input
#shell_1_ratio = input / syncopation_point / sub_divide_half
#shell_2_ratio = input / syncopation_point * shell_1_ratio
#shell_3_ratio = input / syncopation_point * (sub_divide_half
+ sub_divide_from_ceiling) * shell_1_ratio
#shell_4_ratio = input / syncopation_point * shell_2_ratio
#shell_5_ratio = input / syncopation_point * shell_2_ratio
#shell_6_ratio = input / syncopation_point * (sub_divide_half
+ sub_divide_from_ceiling) * shell_1_ratio
#shell_7_ratio = input / syncopation_point * shell_1_ratio
#whole_natural_ratio = shell_4_ratio / shell_3_ratio / shell_2_ratio / shell_1_ratio
#whole_shell_ratio = (shell_7_ratio / shell_2_ratio)
/ (shell_6_ratio / shell_3_ratio)
# / ( shell_5_ratio / shell_4_ratio) / shell_1_ratio
#--------------------#---------------------#---------------------#--------------------#
# Shell Ratios
shell_1_ratio = input / syncopation_point / sub_divide_half
#shell_half / shell_full_count
shell_1_ratio = 0.5 if shell_1_ratio == 0 else shell_1_ratio
#--------------------#---------------------#---------------------#--------------------#
# Shell Ratios
shell_2_ratio = input / syncopation_point * shell_1_ratio
#easepoint_sub_ratio / 100
shell_2_ratio = 0.5 if shell_2_ratio == 0 else shell_2_ratio
#--------------------#---------------------#---------------------#--------------------#
# Shell Ratios
shell_3_ratio = input / syncopation_point * (sub_divide_half
+ sub_divide_from_ceiling) * shell_1_ratio
shell_3_ratio = 0.5 if shell_3_ratio == 0 else shell_3_ratio
#--------------------#---------------------#---------------------#--------------------#
# Shell Ratios
shell_4_ratio = input / syncopation_point * shell_2_ratio
shell_4_ratio = 0.5 if shell_4_ratio == 0 else shell_4_ratio
#--------------------#---------------------#---------------------#--------------------#
# Shell Ratios
shell_5_ratio = input / syncopation_point * shell_2_ratio
shell_5_ratio = 0.5 if shell_5_ratio == 0 else shell_5_ratio
#--------------------#---------------------#---------------------#--------------------#
# Shell Ratios
shell_6_ratio = input / syncopation_point
* (sub_divide_half + sub_divide_from_ceiling) * shell_1_ratio
shell_6_ratio = 0.5 if shell_6_ratio == 0 else shell_6_ratio
#--------------------#---------------------#---------------------#--------------------#
# Shell Ratios
shell_7_ratio = input / syncopation_point * shell_1_ratio
shell_7_ratio = 0.5 if shell_7_ratio == 0 else shell_7_ratio
#--------------------#---------------------#---------------------#--------------------#
# Shell Ratios
max_electron_count = init / ((np/sub_divide_half) * (np/sub_divide_half)) * input
max_electron_count = 0.5 if max_electron_count == 0 else max_electron_count
#--------------------#---------------------#---------------------#--------------------#
# Shell Ratios
whole_natural_ratio = shell_4_ratio / shell_3_ratio / shell_2_ratio / shell_1_ratio
whole_natural_ratio = 0.5 if whole_natural_ratio == 0 else whole_natural_ratio
whole_shell_ratio = (shell_7_ratio / shell_2_ratio)
/ (shell_6_ratio / shell_3_ratio)
/ ( shell_5_ratio / shell_4_ratio) / shell_1_ratio
whole_shell_ratio = 0.5 if whole_shell_ratio == 0 else whole_shell_ratio
#- This shows that all objects in the universe are built on 1/2, 1/3, 1/4 (.5, .33, .25)
ratios
#- Where the system is a perfect circle at 1.5; as groups of quarters equaling 6
#- Where 18 / 3 equals 6, divided by 4 equals 1.5;
and the 6 can be doubled to turn the third into a fourth (12)
' Coming back to; thirds house fourths, and fourths house thirds'
# You will see this when the inputs always give the following ratio
no matter what you enter:
#Shell 1 Ratio is 2.0
#Shell 2 Ratio is 8.0
#Shell 3 Ratio is 18.0
#Shell 4 Ratio is 32.0
#Shell 5 Ratio is 32.0
#Shell 6 Ratio is 18.0
#Shell 7 Ratio is 8.0
'Whole Natural Ratio is 0.1111111111111111'
'Whole Shell Ratio is 0.5'
#---------------------#
# -----------------#
# Easepoints #
# -----------------#
#easepoint = baselimiter / (input / n) /100
#easepoint_subdivide = easepoint * sub_divide_half
#easepoint_sub_ratio = input / easepoint
#L1 = input * .495
#L2 = input * .505
#L3 = input * (1/2)
#L1_third_body_no_impedance = easepoint_subdivide * .495
#L2_third_body_no_impedance = easepoint_subdivide * .505
#L2_third_body_earth_to_jupiter = input * 0.0015
#L3_third_body_no_impedance = easepoint_subdivide * (1/2)
#--------------------#---------------------#---------------------#--------------------#
# Easepoints
easepoint = baselimiter / (input / n) /100
easepoint = 0.5 if easepoint == 0 else easepoint
#- This gives you the orbital distance from a planet to farthest stable reach (moon)
#- You can then divide the input values by the easepoint to break the distance
from the sun to the moon into fractions
#- In this case fourths (400), as both were divided by half
' Or eights if you consider the diameter'
# - To be used later:
# convert_to_whole_100 = input / (input / 4 / 5 / 5)
#--------------------#---------------------#---------------------#--------------------#
# Easepoint Ratios
easepoint_subdivide = easepoint * sub_divide_half
easepoint = 0.5 if easepoint == 0 else easepoint
# - This gives you the diameter for the easepoint
#--------------------#---------------------#---------------------#--------------------#
# Easepoint Ratios
easepoint_sub_ratio = input / easepoint
easepoint_sub_ratio = 0.5 if easepoint_sub_ratio == 0 else easepoint_sub_ratio
#- This gives you the total amount of times the new orbital goes into the input
(mentioned earlier).
' It is a ratio equivalent to shell 2'
' \divide by 100, and you get 8; remember how 10 / 2 / 5 / 5 = 20?'
#- In atoms (8); used later on when calculating shells.
# Use these inputs so you can see what I mean
#Enter Input: 300000000 - sun to earth diameter
#Enter N: 150000000 - sun to earth radius
#Enter NP: 0 - no third body; calculating sun to earth ease points/orbitals
#--------------------#---------------------#---------------------#--------------------#
# Easepoint Locations
# L1 is = Diameter Body To Body * .495
# L2 is = Diameter Body To Body * .505
# L3 is = Diameter Body To Body * .5
# Works for all non-interferent orbits. Larger bodies are allowed due to syncopation.
# Large bodies are a result of the ratios of the system;
# Size and influence are always subject to what the center object can allow.
Never the other way around
' # If there were an object with greater influence, items would syncopate to this object'
' # The different sizes and distances are what hold systems together,
but they exist because of eachother'
' # The same ratios work everywhere'
'This is why you can calculate all of the systems Easepoints
using only the ratio of the sun to one object'
# L2 E to M w/ Jupiter included; Diameter Body to Body (300,000,000) * .5015
# L2 E to M w/ Jupiter included; (using E to M diameter; 750,000) * .6
# E to M uses thirds.
# S to E uses fourths.
# Because these are all whole circle ratios, technically
they are actually all quarter steps
' # That is the significance of the whole natural ratio; 0.1111111111111111 repeating'
' # It is what allows .333, .666, .999 to be used with even numbers'
' # These ratio sets are used throughout all of these equations, and our universe'
#--------------------#---------------------#---------------------#--------------------#
#Easepoint Locations
L1 = input * .495
L1 = 0.5 if L1 == 0 else L1
# - This turns the ratio for nucleus or body to body into halves and thousandths
' L1 being closer to the sun'
#--------------------#---------------------#---------------------#--------------------#
#Easepoint Location
L2 = input * .505
L2 = 0.5 if L2 == 0 else L2
# - This turns the ratio for nucleus or body to body into halves and thousandths
' L2 being away from the sun'
#--------------------#---------------------#---------------------#--------------------#
#Easepoint Location
L3 = input * (1/2)
L3 = 0.5 if L3 == 0 else L3
# - This turns the ratio for nucleus or body to body into halves and thousandths
' L3 being half the diameter from sun to first body'
#--------------------#---------------------#---------------------#--------------------#
#Easepoint Locations
L1_third_body_no_impedance = easepoint_subdivide * .495
L1_third_body_no_impedance = 0.5 if L1_third_body_no_impedance == 0
else L1_third_body_no_impedance
# - This turns the ratio for easepoint or body to body into halves and thousandths
' L1 being closer to the sun'
# - .0011 can be used to get 330,000 but it does not fall
between syncopations from E to M w/ Jupiter
# - .495 will be the perfect circle ratio
# - I will need to write this out starting from Mercury to ensure all results are correct.
# Other planets need to be taken into account for this to work.
# There is a reason the L points are believed to be unstable,
and that is due to missing numbers.
#--------------------#---------------------#---------------------#--------------------#
#Easepoint Location
L2_third_body_no_impedance = easepoint_subdivide * .505
L2_third_body_earth_to_jupiter = input * 0.0015
#\
#- L2 w/ Jupiter can also be be .5015,
but due to binary restrictions, using .5015 results in a rounding error'
#- The error can be bypassed, but I cannot give E to M with Jupiter included
with 100% accuracy yet.
' # This matches current calculations, but there is still a lot of work to be done.'
' # None of this has anything to do with weights, but atomic ratios'
' # Weights are a result of the ratios, and what the closed system allows for shape' \
' # The shape dictates the polarities, which in turn dictate the weights'
L2_third_body_earth_to_jupiter = 0.5 if L2_third_body_earth_to_jupiter == 0
else L2_third_body_earth_to_jupiter
L2_third_body_no_impedance = 0.5 if L2_third_body_no_impedance == 0
else L2_third_body_no_impedance
# - This divides the ratio for easepoint or body to body into halves and thousandths
' L2 being away from the sun; for the first 3 planets,
towards another syncopation (Jupiter)'
' What I still need to work out is multiple planet syncopations'
L3_third_body_no_impedance = easepoint_subdivide * (1/2)
L3_third_body_no_impedance = 0.5 if L3_third_body_no_impedance == 0
else L3_third_body_no_impedance
# - This divides the ratio for easepoint or body to body into halves and thousandths
' L3 being half the diameter from sun to first body'
#---------------------#
# -----------------#
# Falloffs #
# -----------------#
#wave_falloff_for_original_system_1_4 = input * 64
#wave_falloff_for_original_system_1_3 = input * 60
#wave_falloff_os_ratio_check_1_4 = input * 64 / 128
#wave_falloff_os_ratio_check_1_3 = input * 60 / 120
#au_count_for_falloff_1_4 = wave_falloff_for_original_system_1_4 / 150000000
#au_count_for_falloff_1_3 = wave_falloff_for_original_system_1_3 / 150000000
#--------------------#---------------------#---------------------#--------------------#
# Wave Falloff
wave_falloff_for_original_system_1_4 = input * 64
wave_falloff_for_original_system_1_3 = input * 60
wave_falloff_for_original_system_1_4 = 0.5 if wave_falloff_for_original_system_1_4 == 0 \
else wave_falloff_for_original_system_1_4
wave_falloff_for_original_system_1_3 = 0.5 if wave_falloff_for_original_system_1_3 == 0 \
else wave_falloff_for_original_system_1_3
#--------------------#---------------------#---------------------#--------------------#
# Wave Falloff
wave_falloff_os_ratio_check_1_4 = input * 64 / 128
wave_falloff_os_ratio_check_1_3 = input * 60 / 120
wave_falloff_os_ratio_check_1_4 = 0.5 if wave_falloff_os_ratio_check_1_4 == 0 \
else wave_falloff_os_ratio_check_1_4
wave_falloff_os_ratio_check_1_3 = 0.5 if wave_falloff_os_ratio_check_1_3 == 0 \
else wave_falloff_os_ratio_check_1_3
#--------------------#---------------------#---------------------#--------------------#
# Wave Falloff
au_count_for_falloff_1_4 = wave_falloff_for_original_system_1_4 / 150000000
au_count_for_falloff_1_3 = wave_falloff_for_original_system_1_3 / 150000000
au_count_for_falloff_1_4 = 0.5 if au_count_for_falloff_1_4 == 0 \
else au_count_for_falloff_1_4
au_count_for_falloff_1_3 = 0.5 if au_count_for_falloff_1_3 == 0 \
else au_count_for_falloff_1_3
'Wave falloff can calculate system end points. Given these ratios;
and the wave function of atomics;' \
'Calculated falloff comes to 64, or 128 AU; Not previously thought 122.' \
'This is equivalent to the 32nd (fourth) shell ratio'
# You can see that this is correct by entering the last element
in the periodic table as an input
# Using the function of a circle ...
#Enter Input: 118
#Enter N: 3.6875
#Enter NP: 114.3125
'Easepoint Sub Ratio is 12800.0'
#Amplitude Ratios:
# Shell 1 Ratio is 2.0
# Shell 2 Ratio is 8.0
# Shell 3 Ratio is 18.0
# Shell 4 Ratio is 32.0
# Shell 5 Ratio is 32.0
# Shell 6 Ratio is 18.0
# Shell 7 Ratio is 8.0
#Whole Natural Ratio is 0.1111111111111111
#Whole Shell Ratio is 0.5
#---------------------#
# ------------------#
# Wave Rules #
# ------------------#
#orbital_follow_np = shell_half * (np / n)
#orbital_follow_n = shell_half * (n / np)
#shell_full_count = sub_divide_from_ceiling * ds_syncopation_4_5
* (sub_divide_half)
#full_count_ratio = shell_7_ratio / shell_6_ratio / shell_5_ratio \
# / shell_4_ratio / shell_3_ratio / shell_2_ratio / shell_1_ratio
#electron_count_detect = full_count_ratio * IN * 20000000 * sub_divide_half
#--------------------#---------------------#---------------------#--------------------#
# Wave Rules
orbital_follow_np = shell_half * (np / n)
orbital_follow_np = 0.5 if orbital_follow_np == 0 else orbital_follow_np
# This pulls the ratio for points remaining over points traveled.
It will give you fractional increments.
# This is not functional at the moment but left as a reminder
#--------------------#---------------------#---------------------#--------------------#
# Wave Rules
orbital_follow_n = shell_half * (n / np)
orbital_follow_n = 0.5 if orbital_follow_n == 0 else orbital_follow_n
# This is not functional at the moment but left as a reminder
#--------------------#---------------------#---------------------#--------------------#
# Wave Rules
shell_full_count = sub_divide_from_ceiling * ds_syncopation_4_5
* (sub_divide_half)
shell_full_count = 0.5 if shell_full_count == 0 else shell_full_count
#--------------------#---------------------#---------------------#--------------------#
# Wave Rules
full_count_ratio = shell_7_ratio / shell_6_ratio / shell_5_ratio \
/ shell_4_ratio / shell_3_ratio / shell_2_ratio / shell_1_ratio
full_count_ratio = 0.5 if full_count_ratio == 0 else full_count_ratio
'These two are incomplete, and meant for over time calculations'
#--------------------#---------------------#---------------------#--------------------#
# Wave Rules
electron_count_detect = full_count_ratio * IN * 20000000 * sub_divide_half
electron_count_detect = 0.5 if electron_count_detect == 0 else electron_count_detect
'These two are incomplete, and meant for over time calculations'
#--------------------#---------------------#---------------------#--------------------#-
# -- PLEASE READ TO UNDERSTAND: -- #
# You can calculate outwards and then come back
# When you have 10 electrons, this results in a falloff of 640;
which is a proponent of 32, which is the half, or ...
# ... Polarity opposition point for a sine wave
# It tells us that atoms are built on whole number ratios up to 10
# If you divide the maximum allowed electron count for the periodic table (118) by 32,
it results in 3.6875
# You can then enter this number into the calculator:
# Enter IN: 118
# Enter N: 3.6875
# Enter NP: 114.3125
# This is the function of a perfect circle. As a whole; dividing the input by the results
...
#Orbit Plots:
#Wave Falloff for Original System Ratio Check is 59.0
' #Wave Falloff for Original System is 7552.0. Divide this by 118, and you get 64;
or 128 to 59'
' 59 is 1/4 of the DS_syncopation'
#AU Count For Original System is 5.0346666666666663e-05
#Orbital Easepoint is 0.00921875.
#Easepoint Subdivide is 0.0184375
' #Easepoint Sub Ratio is 12800.0; a function of 32; same as the wave falloff '
# L2 and L3 are whole counterparts. L1 is a proponent of allowed space,
or syncopation between two points.
# It is why all of this can be done.
#-----------------#
init = 0.5 if init == 0 else init
baselimiter = 0.5 if baselimiter == 0 else baselimiter
easepoint = 0.5 if easepoint == 0 else easepoint
sub_divide_from_ceiling = 0.5 if sub_divide_from_ceiling == 0
else sub_divide_from_ceiling
ds_syncopation_4_5 = 0.5 if ds_syncopation_4_5 == 0 else ds_syncopation_4_5
syncopation_point = 0.5 if syncopation_point == 0 else syncopation_point
shell_half = 0.5 if shell_half == 0 else shell_half
whole_ratio_combine = 0.5 if whole_ratio_combine == 0 else whole_ratio_combine
whole_ratio = 0.5 if whole_ratio == 0 else whole_ratio
shell_1_ratio = 0.5 if shell_1_ratio == 0 else shell_1_ratio
shell_2_ratio = 0.5 if shell_2_ratio == 0 else shell_2_ratio
shell_3_ratio = 0.5 if shell_3_ratio == 0 else shell_3_ratio
shell_4_ratio = 0.5 if shell_4_ratio == 0 else shell_4_ratio
shell_5_ratio = 0.5 if shell_5_ratio == 0 else shell_5_ratio
shell_6_ratio = 0.5 if shell_6_ratio == 0 else shell_6_ratio
shell_7_ratio = 0.5 if shell_7_ratio == 0 else shell_7_ratio
max_electron_count = 0.5 if max_electron_count == 0 else max_electron_count
whole_natural_ratio = 0.5 if whole_natural_ratio == 0 else whole_natural_ratio
whole_shell_ratio = 0.5 if whole_shell_ratio == 0 else whole_shell_ratio
easepoint = 0.5 if easepoint == 0 else easepoint
easepoint = 0.5 if easepoint == 0 else easepoint
easepoint_sub_ratio = 0.5 if easepoint_sub_ratio == 0 else easepoint_sub_ratio
L1 = 0.5 if L1 == 0 else L1
L2 = 0.5 if L2 == 0 else L2
L3 = 0.5 if L3 == 0 else L3
L1_third_body_no_impedance = 0.5 if L1_third_body_no_impedance == 0
else L1_third_body_no_impedance
L2_third_body_earth_to_jupiter = 0.5 if L2_third_body_earth_to_jupiter == 0
else L2_third_body_earth_to_jupiter
L2_third_body_no_impedance = 0.5 if L2_third_body_no_impedance == 0
else L2_third_body_no_impedance
L3_third_body_no_impedance = 0.5 if L3_third_body_no_impedance == 0
else L3_third_body_no_impedance
wave_falloff_for_original_system = 0.5 if wave_falloff_for_original_system == 0
else wave_falloff_for_original_system
wave_falloff_os_ratio_check = 0.5 if wave_falloff_os_ratio_check == 0
else wave_falloff_os_ratio_check
au_count_for_falloff = 0.5 if au_count_for_falloff == 0 else au_count_for_falloff
orbital_follow_np = 0.5 if orbital_follow_np == 0 else orbital_follow_np
orbital_follow_n = 0.5 if orbital_follow_n == 0 else orbital_follow_n
shell_full_count = 0.5 if shell_full_count == 0 else shell_full_count
#-----------------#
print("\n---\n\n"
"Input Ratios:\n\n"
" Initial Entry is {0}.\n"
" Baselimiter is {1}.\n"
" DS Syncopation 4/5 is {2}.\n"
" Shell Half is {3}\n"
" Sub Divide From Ceiling {4}.\n"
" Syncopation Point is {5}.\n"
" Whole Ratio Combine is {6}\n"
" Whole Ratio is {7}\n\n\n"
"*Base Limiter and Sub Ratio are quarter ratios based on the inputs;\n"
" Using Distance Traveled (N), And Remaining Points
" or Distances From The Initial Entry (NP)\n"
" They are functions of addition in that Baselimiter"
"+ Sub Ratio gives you the whole ratio to the input.\n\n"
"---\n\n"
" Amplitude Ratios:\n\n"
" Max Electron Count is {30}\n\n"
" Shell 1 Ratio is {14}\n"
" Shell 2 Ratio is {15}\n"
" Shell 3 Ratio is {16}\n"
" Shell 4 Ratio is {17}\n"
" Shell 5 Ratio is {18}\n"
" Shell 6 Ratio is {19}\n"
" Shell 7 Ratio is {20}\n\n"
"Whole Natural Ratio is {21}\n"
"Whole Shell Ratio is {22}\n\n"
"---\n"
" Orbit Plots:\n\n"
" Wave Falloff for Original System Ratio Check is {23}\n"
" Wave Falloff for Original System is {24}\n"
" AU Count For Original System is {29}\n\n"
" Orbital Easepoint is {8}.\n\n"
" Easepoint Subdivide is {9}\n"
" Easepoint Sub Ratio is {10}\n\n"
" L1 as a radius from the input (Nucleus) is {11}.\n"
" L2 as a radius from the input (Nucleus) is {12}.\n"
" L3 as a radius from the input (Nucleus) is {13}.\n\n"
" Second Body L1 as a radius from n is {25}\n"
" Second Body L2 as a radius from n is {26}\n"
" Earth to Moon L2 with Jupiter included is {27}\n"
" Second Body L3 as a radius from n is {28}\n\n"
"These are locations for orbitals, where the extensions of the
system follow syncopations.\n\n\n"
.format
(init #0
, baselimiter #1
, ds_syncopation_4_5 #2
, shell_half #3
, sub_divide_from_ceiling #4
, syncopation_point #5
, whole_ratio_combine #6
, whole_ratio #7
, easepoint #8
, easepoint_subdivide #9
, easepoint_sub_ratio #10
, L1 #11
, L2 #12
, L3 #13
, shell_1_ratio #14
, shell_2_ratio #15
, shell_3_ratio #16
, shell_4_ratio #17
, shell_5_ratio #18
, shell_6_ratio #19
, shell_7_ratio #20
, whole_natural_ratio #21
, whole_shell_ratio #22
, wave_falloff_os_ratio_check #23
, wave_falloff_for_original_system #24
, L1_third_body_no_impedance #25
, L2_third_body_no_impedance #26
, L2_third_body_earth_to_jupiter #27
, L3_third_body_no_impedance #28
, au_count_for_falloff #29
, max_electron_count)) #30