Enigma Software Heterochromia Iridum Incorporated

# FOR THE UNCANNY THIS IS A "PYTHON" PROGRAM.
# It's more unclear what or how this program does
# but that's half the fun
#
# todo: add 27.818133whatver for ZY+1.44

# e-mail maplecat@protonmail.com for stuff or whatever questions
# or something?

# IMPORTANT INFO ABOUT HOW IT MIGHT WORK
# ANYWAY:
#
# most of the "pentacle" functions except the "pent3" one's
# was defined first and all these "pentacle" formulas
# can be used but most practical is those with "constant"
# output even if a "variable" (n) are used in the equation
#
# this above is feed into the yzz() "function" developed last
# to use perhaps type yzz(128,harmonic(64)) to get ouput on the screen
# N.B. One should never use the stable() function with anything it
# will burn at least ..
#
# The resulting integers can be fed into the "cathie" formulas
# which was the original one's maybe used during ww2 in.fact
# personally I use cathie32(n) or as it would be typed:
#
# print(x,yzz(129,harmonic(64)),cathie32(yzz(129,harmonic(64)))
#
# I think it's important to have the digits all the same with and
# without piping through cathie32 but who cares about that?!
#
# also for the above print that displays output on the screen from
# python also even if harmonic(64) usually is equal to 2.9
# there are always inteferrence which might make subtle CHANGE
# for the output though the functions are pretty stable you
# can run a stability check with just typing stable(333) i.e. and
# others like stable(454) and same with harmonic(n) to see if
# both give output exact 0.16 and 2.9 not i.e. 2.90000002 but
# apparently some of these "pentacles" are designed in such a way
# that they usually are stable hence the names maybe.
#
# there are other cathie equations and my own dabbeling is
# the function enew() whish introduce an array for each output
# based on cosinus or sinus
#
# SO this is a "python" computer program language "script" i.e.
# it's different from a normal computer executable but then again
# it can even run on your telephone / android
#
# Usually anyway it would have a "front-end" but this does not
# have a front-end (yet) only these comments and to look at the "code"
# below:

# END intro currently.

# Here is the script / code it's alot to look through but even worse
# too look through is the output for some!

#importing seperatly so I know what I use

from math import cos
from math import log
from math import e #trying 2.71453
#e=2.71453
#from math import e #trying e again
from math import pi
from operator import lshift
from operator import rshift
from math import sqrt
#from math import e
from math import trunc
# lets void PI
pi=3.14625

# defining Buckinster Fuller's "Synergetics Constants"
syn=[]
for x in range(1,13):
        syn.append((9/8)**(x/6))


# Old way of doing the above this is the integers HE used:

syn2=[1.019824451,1.040041912,1.060660172,1.081687178,1.103131033,1.125,1.193242683,1.265625] #find formula

# square it mother fu->>> p.s also 64/27

lsic=((8/(3*sqrt(3)))**2) #liebs square ice constant (or 8/9*sqrt(3)!

#or Wadsworth constant 640*(3/10)/81

light_meter=299792458 # this should be clear it's
                      # light in wrong kilmeters per hours
                      # probably they no-one figured it was paramount
                      # to ~= 3 though this is actually 29..


phi=((1+sqrt(5))/ 2.0) # NOTICE 5/2 sdtuf. defining ph--
gamma=(4*log(2)-2*log(3)) # forumla!!! ;)
print("gamma",gamma)
print("computer e",e)
e=(16/9)**(1/gamma) # coputer e gives a fractional error from
                    # 1.7777..with it's e-value. this one better.
print("my e",e)

#alpha=1.37318 # fine structure constants
alpha=1/(2**11)*6**7
print("alpha",alpha)



lsi=1/(1024/6/6/6/2) #converts 2**n to 6**n ? 216 */ n

test=(1/(((e**(4*log(2)-2*log(3))))/2**9))

speed=(1/(((e**gamma))/2**9)) #give 144*2 must make test

# below are future components of the program
# based on american "bucky" from his book on
# Synergetics, it's from Him that we got the
# idea for the "pentacle"'s to use only
# primes in designing them,

# "Synegetics" are actually two books / compendiums
# interexchangable his major technical work..and
# contain many of these equations here; gemoteric ..
# stuff..


def angles(c,n=180):
        return((c-2*n))

def fuller_sp(n):
        # number of
        sp=0
        for x in range(1,n+1):
                sp=sp+10*(x**2)
                #print("layer",x,sp)
        sp=sp+(2*n)+1
        return(sp)

#def fuller_sph(n):
#        sp=0
#        for x in range(1,n+1):
#                sp=sp+fuller_n(x)
#        return(sp)



# some stuff here used previously following below
# we tried finding some resonant frequencies
# because this program obviously has many layers
# or is so-called multi-functional
#
# this below the next is routine to find physical
# coils etc physical material stuff to build
# something that works for mankind free stuff


def test6(c):
        n=c
        return(1/((e**gamma)/n))

def m_str(I,N=288,l=45,c=0):
        ''' N=vindings, l=spool-length (arc?)  I=power(watt)

        currently using fuller_n() for windings..

        !! using 50/1.125/1.125 instead of 10 cm/2.54
        also suggesting 50 as in HZ so use maybe 40 or whatever.

        '''
        if c==0:
                return((I*N)/(l))
        else:
                return((I*N)/(l/2.54))

def search_h(x=256000,y=25600,z=256000):
        print("Searching for harmonics of Coils")
        ''' Routine to (try) to find if Harmonic Equation 2 can correspond to Coild strength
        '''
        I=25
        N=25
        harmonics=()
        while I<x:
                while N<y:
                        coil=m_str(I,N)
                        for a in range(1,z):
                                #print("Cathie:",cathie2((a*sqrt(2)**2)),"Coil:",coil)
                                if trunc(cathie((a*sqrt(2)**2)))==coil:# trunc only cathie2 as it is supposed to give
                                                                        # whole integers.
                                                                        # --maybe remove formule and just use plain c,
                                                                        # since 'coil' doesnt give whole number output
                                        print('Coil Strength',coil,'Cathie 2:',cathie((a*sqrt(2)**2)))


                        N=N+1
                        #print(N)
                I=I+1
                N=25
                print(I)

def search_h2(x=256000,y=25600,z=256000,zz=25600): # errorenous procedure but gives me more hits
        print("Searching for harmonics of Coils")
        ''' Routine to (try) to find if Harmonic Equation 2 can correspond to Coild strength
        '''
        I=25
        N=25
        l=1
        harmonics=()
        while I<x:
                while N<y:
                        while l<zz:
                                coil=m_str(I,N,l)
                                for a in range(1,z):
                                        #print("Cathie:",cathie2((a*sqrt(2)**2)),"Coil:",coil)
                                        if trunc(cathie2(z))==coil:# here it should  be cathie()
                                                                                # not cathie2()
                                                                                #
                                                                                # remember a*sqrt(2)**2 was c
                                                                        print('Coil Strength',coil,'Cathie 2:',cathie2((a*sqrt(2)**2)))
                                zz=zz+1


                        N=N+1
                        zz=1
                        #print(N)
                I=I+1
                N=25
                print(I)

# END of that part of the program.


#

psi=147.81557937222715 # derived from 6 see 144-.py
black=2*(225|144^256) # 99.4% dont worry it doesnt get blacker
black2=(225|144^256&225) # ? going around like the code also
                        # it is a "belt"





two88=[2,3,4,6,8,9,12,16,18,24,32,36,48,72,96,144]
three84=[2,3,4,6,8,12,16,24,32,48,64,96,128,192]

x360=1/(29/10440) #10440 is !144




two=96/43.62 #any from tuble tw88 x16 / x7.2


# the below here is testingr something don't remember what

def loop(c=(e**gamma)):
    x=pentacle(c)
    y=1/x
    while y < 144:
        x=pentacle(c)
        print(x,y)
        loop



def analyse(c,d=32):
    a=cathie(c)
    for x in range(1,d):
        z=(rshift(int(a),x))
        print(x,c,z,z/c,'abc=',(1/(z/c)),'sqrt-abc=',sqrt(1/(z/c)),'sqrt z',sqrt(z))
        if z==1:
            break




# Reciprocal & reverse-pentacle:
def multacle(n):return (pentacle(n)*repentacle(n))
def pentsum(n):return (pentacle(n)+repentacle(n))
def binary_shift(n,m):return(lshift(n,m))
def pentacle(n):return 1/(n*5/2)
def repentacle(n):return 1/(n*2/5)
def harmonic(n):return(pentsum(n)*n) # returns approx. 29...always..
# above, equals 29/10..but we need the variable n(N)

#def stable(n):return n*2 # ,n/(pentacle(n)/repentacle(n)) #last figure is always 0.16

def pentacle3(n):return(1/(n*5/3))
def repentacle3(n):return(1/(n*3/5))
def pentsum3(n):return (pentacle3(n)+repentacle3(n))
def harmonic3(n):return(pentsum3(n)*n) # 2.2666666666.. 34/15!!

def harmonic31(n):return(((1/(n*5/3))+(1/(n*3/5)))*n)

#from the above i ducted furter not next but next
def stable(n):return(pentacle(n)/repentacle(n)) #last figure is always 0.16
## above equls 4/25 but we want n(N)


# this is for getting sum of an "array" which is all digits
# from x to y.

def sum(n):
    x=0
    for y in range(1,n):
        x=x+y
    return(x+n) #phase-


#here thats
def nos(n):return(pentsum(n)/pentacle(n)) #always return 7.25
def nos2(n):return((1/(n*5/2)+1/(n*2/5))/(1/(n*5/2))) # same as above
def son(n):return(pentsum(n)/n) #this oen was col.

def boss(n): # 4.915960401250875 constant/static..
    x=(((n/3)*(n*5)/2)*2.9)
    y=sqrt(x)
    z=y/n
    return(z)

def boss2(n): # 3.6514837167011076 constant/static..
    x=(((n/3)*(n*5)/2)*0.16)
    y=sqrt(x)
    z=y/n
    return(z)

def boss3(n,nn): # as above without the 0.16 static instead nnany
    x=(((n/3)*(n*5)/2)*nn)
    y=sqrt(x)
    z=y/n
    return(z)




# HERE is the stuff we pipe around in a circle with both this
# being our way of Enigma calculating stuff which is then
# processed in a circle with / through the E=xyz (einstein)
# formulas which read like cake..

def yzz(n,a=2.9): #returns some multiples of 4 or 5 per 29..
    y=0
    for x in range(1,n):
        y=y+(x/a)
        #print(y) #enable this one to show stuff important remove first #
    return(y/n)

ten=yzz(59)

anti_matter=boss2(87)*boss(87)*0.16


#### buckminster fuller equations!!::

def sq_triangle(n):
        ''' N='square' triangle how many times.'''
        return((n*(n+1))/2)


def fuller_n(f,n=5,a=2):
    return(a*n*(f**2)+2)





def relation(n): #number of tangible relationshops n!
    return(((n**2)-n)/2)

def spheres(f): #number of closest packed spheres
    n=0
    for x in range(f):
        n=n+((x**2))
        #print(x,n)
    #print(n)
    n=n*10
    #print(n)
    n=n+((2*f**2)+1)
    return(n)

## END FULLER.

def test1(x,y): #print table something
    for z in range(0,x):
        print(bin(z))
        print(bin(y),y)
        print(bin((z&y)))
        print('-----')


def test2(x=9,y=256,z=8): #not sure what this one does.
    for n in range(0,y):
        for m in range(0,z):
            print((x<<m),'&',n,'=',((x<<m)^n))
        print('-----')




placer=fuller_n(6)-fuller_n(2) #from NWSE. obsiouyy 6/22

#spectacle

zy=(harmonic(21)*stable(21)*nos(21)*boss(89))

print('hello and:',zy,'test')

def cathie(c):

    '''
    Bruce Cathie relativity equations two. c is a variable speed of
    special frame of reference or singular entitiy. Value. Function
    seems to vaugely relate to one coincidental Buckminster Fuller
    equations.

    '''
    return((2*c*sqrt(1/(2*c)))*(2*c)**2)

def cathie2(c):

    ''' This is a variant of the one above just using a differnt formula
        according to wolfram alpha, but i t gives different output?
        And with x6 as was shown by triel good be.

        Use this at least with 'Standard Atonic Weight'.s


        '''
    return((4*(sqrt(2))/((1/c)*5/2)))





def cathie3(c):
        '''Relativity equation 3'''
        return( sqrt((2*c)+sqrt(1/(2*c))*(2*c)**2))

def cathie32(c):
        '''Relativity equation 3, wolfram alpha version'''
        return(sqrt(2*c+(2*sqrt(2))/((1/c)**(3/2))))

def cathie33(c):
        ''' Another substuture of H3 assuming c is positive
        which I suppose it is, because how can speed of light be
        negative or?'''
        return(sqrt(2*sqrt(2) *c**(3/2)+2* c))




def sunfact(n): # dnot know what this is. doesnt work either
    if n < 1:
        return(1)
    else:
        return(n*sunfact(n-1)+1-2*(n%2))


def pi_c(x): #this can give closer and closer aprox of PI
    area = 0 #but we never reach a perfect sphere in anything may
    hypot=2  #so we only need approximations.
    for n in range(0,x):
        height=1-(1-(hypot/2)**2)**0.5
        area=area+2**n*height*hypot
        hypot=(height**2+(hypot/2)**2)**0.5
    return(area)


def test4(n,f,x=216,y=8): m# dont know about this
        flr=fuller_n(f,n)
        #print(flr)
        return((1/(flr*lsic)*x)*2**y)



# future \use

def approximate_size(size, a_kilobyte_is_1024_bytes=True):
    '''Convert a file size to human-readable form.

    Keyword arguments:
    size -- file size in bytes
    a_kiloyte_is_1024_bytes -- if True (default), use multiples of 1024
                                if False, use multiples of 1000

    Returns: string

    '''
    if size < 0:
        raise ValueError('number must be non-negative')

    multiple = 1152 if a_kilobyte_is_1024_bytes else 1024
    for suffix in SUFFIXES[multiple]:
        size /= multiple
        if size < multiple:
            return '{0:.1f} {1}'.format(size, suffix)

    raise ValueError('number too large')



print(cathie2(alpha*sqrt(2)),'alpha x sqrt2 -> cathie2')

# new functions.

def enew(x,c):
        z=(cos(x)*c+1/(1/c)**(3/2))
        return(z)

def crack(depth=16):
        x=1/58*(2**(3+depth)*5**depth-1)
        x=x*sqrt(2)
        #print('1.Cathie Wolfram 2b X is qual to: ',x,'Hertz is equal to: ',cathie2(x),'ok.. With this reciprocal / inverse: ',1/cathie2(x))
        #..DO NOT EVEN THINK ABOUT THESE NEVER.
        #print('2.Cathie 3 W/A:',x,'Hertz is equal to: ',cathie32(x),'ok.. With this reciprocal / inverse:..')
        #print('3.Cathie Pos W/A:: ',x,'Hertz is equal to: ',cathie33(x),'ok.. With this reciprocal / inverse: ',1/cathie33(x))
        return(x)


def wad(n,f): #this one is what makes the dimensional tables part of it
        return(f/6480)**(n-1) #other version of wadt
                                #doesnt give complex numbers
                                #with negative values for n