myl.py

import sympy
from sympy import *
import numpy as np
from numpy import linalg as LA
from numpy.linalg import inv
import math
def get(tpe,life):
	with open(""+tpe+""+life+".txt", "r") as x:
		a1reader=csv.reader(x)
		a1list= []
		for row in a1reader:
			if len(row)!=0:
				a1list=a1list + [row]
		return a1list
	x.close()


def powervec(x,number_of_floors):
	vewc=np.zeros((number_of_floors))
	for x in range(number_of_floors):
		vewc[x]=1
	return vewc

def make_A_matrix(number_of_floors,mass_of_floor,floor_string_constents):
	pass

	promat=[""]*number_of_floors
	for x in range(number_of_floors):
		promat[x]=[0]*number_of_floors

	promat[0][0]=-(floor_string_constents[0]+floor_string_constents[1])/mass_of_floor[0]
	promat[0][1]=(floor_string_constents[1])/mass_of_floor[0]



	promat[number_of_floors-1][number_of_floors-1]=-(floor_string_constents[number_of_floors-1]+floor_string_constents[number_of_floors])/mass_of_floor[number_of_floors-1]
	promat[number_of_floors-1][number_of_floors-2]+=(floor_string_constents[number_of_floors-1])/mass_of_floor[number_of_floors-1]


	for x in range(number_of_floors-2):
		promat[x+1][0+x]=(floor_string_constents[x+1])/mass_of_floor[x+1]
		promat[x+1][1+x]=-(floor_string_constents[x+1]+floor_string_constents[x+2])/mass_of_floor[x+1]
		promat[x+1][2+x]=(floor_string_constents[x+2])/mass_of_floor[x+1]

	commat=Matrix(promat)
	return commat

def floor_duble_eqations_F(number_of_floors,floor_string_constents,floor,mass_of_floor):
	pass
	floor_dubble=[""]*number_of_floors

	floor_dubble[0]=(-(floor_string_constents[0]+floor_string_constents[1])*floor[0]+floor_string_constents[1]*floor[1])/mass_of_floor[0]+(force_form_eq_on_flor[0])/mass_of_floor[0]

	floor_dubble[number_of_floors-1]=-(floor_string_constents[number_of_floors]+floor_string_constents[number_of_floors-1])*floor[number_of_floors-1]
	floor_dubble[number_of_floors-1]+=(floor_string_constents[number_of_floors-1])*floor[number_of_floors-2]
	floor_dubble[number_of_floors-1]=floor_dubble[number_of_floors-1]/mass_of_floor[number_of_floors-1]
	floor_dubble[number_of_floors-1]+=(force_form_eq_on_flor[number_of_floors-1])/mass_of_floor[number_of_floors-1]
	print(mass_of_floor[number_of_floors-1])


	for x in range(number_of_floors-2):
		floor_dubble[x+1]=floor_string_constents[x+1]*floor[x]
		floor_dubble[x+1]+=-(floor_string_constents[x+1]+floor_string_constents[x+2])**floor[x+1]
		floor_dubble[x+1]+=floor_string_constents[x+2]*floor[x+2]
		floor_dubble[x+1]=floor_dubble[x+1]/mass_of_floor[x+1]
		floor_dubble[x+1]+=force_form_eq_on_flor[x+1]/mass_of_floor[x+1]
	return floor_dubble


def getmatrix_A_F(number_of_floors,eval_A_mat):
	evl_matrix=np.zeros((number_of_floors, number_of_floors))
	for x in range(number_of_floors):
		for y in range(number_of_floors):
			evl_matrix[x][y]=eval_A_mat[x*number_of_floors+y]
	return evl_matrix

def eval_matrix_A(commat,floor_string_constents,mass_of_floor,valmass):

	for x in range(number_of_floors):
		commat=commat.subs(floor_string_constents[x], valk[x]).subs(mass_of_floor[x], valmass[x])


	commat=commat.subs(floor_string_constents[number_of_floors], valk[number_of_floors])

	return commat



def powerfunc_F(powerF_2_1mat):
	powerF_2taylor=[0]*len(powerF_2_1mat[0])
	for x in range(len(powerF_2_1mat)):
		for y in range(len(powerF_2_1mat[0])):
			powerF_2taylor[y]+=powerF_2_1mat[x][y]*(time**x)
	return powerF_2taylor
def powerfunc_withmax_F(powerF_2_1mat,mx):
	powerF_2taylor=[0]*len(powerF_2_1mat[0])

	if len(powerseries)<=mx:
		mx=len(powerF_2_1mat)

	for x in range(mx):
		for y in range(len(powerF_2_1mat[0])):
			powerF_2taylor[y]+=powerF_2_1mat[x][y]*(time**x)
	return powerF_2taylor
def sol_f_1_l_F(number_of_floors,egonval):
	pass
	f_1_l=[0]*number_of_floors
	con1=[""]*number_of_floors
	con2=[""]*number_of_floors
	for x in range(number_of_floors):
		con1[x] = Symbol('c'+str(2*x+1)+"")
		con2[x] = Symbol('c'+str(2*x+2)+"")
		if egonval[0][x]>=0:
			add=con2[x]*sinh(math.sqrt(abs(egonval[0][x]))*(time+con1[x]))
		else:
			add=con2[x]*sin(math.sqrt(abs(egonval[0][x]))*(time+con1[x]))
		for y in range(number_of_floors):
			f_1_l[y]+=egonval[1][y][x]*add
	return Matrix(f_1_l)


def sol_f_1rows_l_F(number_of_floors,egonval):
	print(egonval[1][3][3])
	add=0
	f_1_l=[0]*number_of_floors
	cont1=[""]*number_of_floors
	cont2=[""]*number_of_floors
	for y in range(number_of_floors):
		vec=[0]*number_of_floors
		for x in range(number_of_floors):
			vec[x]=float(egonval[1][x][y])
		cont1[y] = Symbol('c'+str(2*y+1)+"")
		cont2[y] = Symbol('c'+str(2*y+2)+"")
		if egonval[0][y]>=0:
			add=cont2[y]*sinh(math.sqrt(abs(egonval[0][y]))*(time+cont1[y]))
		else:
			add=cont2[y]*sin(math.sqrt(abs(egonval[0][y]))*(time+cont1[y]))
	
		f_1_l[y]=[Matrix(vec),add]
	return f_1_l

def get_invA_F(evl_matrix):
	return inv(evl_matrix)

def get_egonvalA_F(evl_matrix):
	return LA.eig(evl_matrix)


def get_powerseries_F(number_of_floors,func):
	pass
	powerseries=[""]*3

	for x in range(len(powerseries)):
		powerseries[x]=func(x,number_of_floors)
	
	return powerseries

def get_cosseries_F(number_of_floors,func):
	pass
	cos_series=[""]*1

	for x in range(len(cos_series)):
		cos_series[x]=[2,func(x,number_of_floors)]
	
	return cos_series
def getnubmer_F():
	while 1:
		pass
		number=input("enter a number :")
		try:
			int(number)
			return int(number)
		except Exception as e:
			pass
			#print("not a number")

def getfloat_F():
	while 1:
		pass
		number=input("enter a float :")
		try:
			float(number)
			return float(number)
		except Exception as e:
			pass
			#print("not a number")

def f_vec_F(number_of_floors):
	difvect=[""]*number_of_floors
	for x in range(number_of_floors):
		difvect[x]=force_form_eq_on_flor[x]

	difmat=Matrix(difvect)
	return difmat


def fl_vec_F(number_of_floors,floor):
	pass
	florvec=[""]*number_of_floors
	for x in range(number_of_floors):
		florvec[x]=floor[x]
	return Matrix(florvec)


def fldp_vec_F(number_of_floors,floordb):
	pass
	florvec=[""]*number_of_floors
	for x in range(number_of_floors):
		florvec[x]=floordb[x]
	return Matrix(florvec)

def fldp_vec_F2(number_of_floors,floordb):
	pass
	florvec=[""]*number_of_floors
	for x in range(number_of_floors):
		florvec[x]=[floordb[x]]
	return Matrix(florvec)
#number_of_floors=getnubmer_F()
add=""
add+="\documentclass{article}\n"
add+="\\title{Project}\n"
add+="\date{2018-05-01}\n"
add+="\\author{Alex haussmann}\n"
add+="\\usepackage{amsmath}\n"
add+="\\begin{document}\n"
add+="\pagenumbering{gobble}\n"
add+="\maketitle\n"
add+="\\newpage\n"
add+=" \pagenumbering{arabic}\n"
add+="\paragraph{}\n"
number_of_floors=4

time=Symbol('t')

#floor vecor
floor=[""]*number_of_floors
for x in range(number_of_floors):
	floor[x] = Symbol('fl'+str(x+1)+"")

floordb=[""]*number_of_floors
for x in range(number_of_floors):
	floordb[x] = Symbol('fl_{'+str(x+1)+"}''")

floor_string_constents=[""]*(number_of_floors+1)

for x in range(number_of_floors+1):
	floor_string_constents[x] = Symbol('k'+str(x+1)+"")
#print(floor_string_constents[0])

force_form_eq_on_flor=[""]*number_of_floors

for x in range(number_of_floors):
	force_form_eq_on_flor[x] = Symbol('f'+str(x+1)+"")

# floor masses
mass_of_floor=[""]*number_of_floors
for x in range(number_of_floors):
	mass_of_floor[x] = Symbol('m'+str(x+1)+"")

# creating the matrix A
add+=" floor pos=fl\n"
add+="\paragraph{}\n"
add+=" mass of floot=m\n"
add+="\paragraph{}\n"
add+=" external force on floor = f\n"
add+="\paragraph{}\n"
add+=" spring consent on floor = k\n"
add+="\paragraph{}\n"



floor_duble_eq=floor_duble_eqations_F(number_of_floors,floor_string_constents,floor,mass_of_floor)


if input("display eqations? y/n").lower()=="y":
	add+="\paragraph{}\n"
	add+="\paragraph{}\n"
	add+="\paragraph{}\n"
	add+="the govering eqations are\n"
	for x in range(len(floor_duble_eq)):
		#print("fl"+str(x+1)+"''=")
		
		pprint(floor_duble_eq[x])
		add+="\paragraph{}\n"
		add+="$$"+"fl''_{"+str(x+1)+"} = "+latex(floor_duble_eq[x])+"$$\n"
		#print()

if input("explain eqations? y/n").lower()=="y":
	#print("whatever the expaination is")
	add+="\paragraph{}\n"
	add+="whatever the expaination is\n"
	add+="\paragraph{}\n"
	add+="\paragraph{}\n"
	add+="\paragraph{}\n"


##this is where the vectors are
flvec=fl_vec_F(number_of_floors,floor)
add+="$$"+"\\vec{fl}"+" = "+latex(flvec)+"$$\n"
#input("contue")

flvecdp=fldp_vec_F(number_of_floors,floordb)
add+="$$"+"\\vec{fl}''"+" = "+latex(flvecdp)+"$$\n"
#input("contue")fldp_vec_F2
add+="\paragraph{}\n"
add+="\paragraph{}\n"
add+="\paragraph{}\n"


#A=

commat=make_A_matrix(number_of_floors,mass_of_floor,floor_string_constents)
add+="$$"+latex(commat)+"$$\n"
#add+=latex(commat)+"\n"
#if input("explain how matrix is generated? y/n").lower()=="y":
#	print("whatever the expaination is")

#input("continue")


add+="\paragraph{}\n"
#input("continue")
add+="$$"+"\\vec{f}"+" = "+latex(f_vec_F(number_of_floors))+"$$\n"


add+="\paragraph{}\n"
add+="$$"+"\\vec{fl''}"+" = "+"A*\\vec{fl}+\\vec{f}"+"$$\n"

valk=[0]*(number_of_floors+1)
#lip=input("imput k line my line y else all with be the same")
lip="n"
if lip.lower()=="y":
	for x in range(number_of_floors):
		#print("k"+str(x+1)+"")
		valk[x]=getfloat_F()
else:
	#kallv=getfloat_F()
	kallv=1
	for x in range(number_of_floors):
		valk[x]=kallv



valmass=[0]*number_of_floors

#lip=input("imput m line my line y else all with be the same")
lip="n"
if lip.lower()=="y":
	for x in range(number_of_floors):
		#print("m"+str(x+1)+"")
		valmass[x]=getfloat_F()
else:
	#kallv=getfloat_F()
	kallv=1
	for x in range(number_of_floors):
		valmass[x]=kallv


add+="\paragraph{}\n"
add+="we have in this example set\n"
add+="$$"+"\\vec{k}"+" = "+latex(Matrix(valk))+"$$\n"
add+="\paragraph{}\n"
add+="$$"+"\\vec{m}"+" = "+latex(Matrix(valmass))+"$$\n"
add+="\paragraph{}\n"
add+="\paragraph{}\n"

floor_part1=[""]*number_of_floors
floor_part2=[""]*number_of_floors
floordb_part1=[""]*number_of_floors
floordb_part2=[""]*number_of_floors
for x in range(number_of_floors):
	floor_part1[x] = Symbol('f_1_l'+str(x+1)+"")
	floor_part2[x] = Symbol('f_2_l'+str(x+1)+"")
	floordb_part1[x] = Symbol('f_1_l\'\''+str(x+1)+"")
	floordb_part2[x] = Symbol('f_2_l\'\''+str(x+1)+"")

add+="\paragraph{}\n"
add+="now we solve the brake the problem we sovle\n"
add+="\paragraph{}\n"
add+="$$"+"\\vec{fl}"+" = "+"\\vec{fl_{1}}+\\vec{fl_{2}}"+"$$\n"
add+="\paragraph{}\n"
add+="$$"+"\\vec{fl_{1}}''"+" = "+"A*\\vec{fl_{1}}"+"$$\n"
add+="generaly and\n"
add+="\paragraph{}\n"
add+="$$"+"\\vec{fl_{2}}''"+" = "+"A*\\vec{fl_{2}}+\\vec{f}"+"$$\n"
add+="spisicifly\n"

add+="\paragraph{}\n"


add+="the evaluated matrix A is\n"

add+="\paragraph{}\n"



eval_A_mat=eval_matrix_A(commat,floor_string_constents,mass_of_floor,valmass)
add+="$$"+latex(eval_A_mat)+"$$"

evl_matrix=getmatrix_A_F(number_of_floors,eval_A_mat)

egonval=LA.eig(evl_matrix)

add+="\paragraph{}\n"
add+="\paragraph{}\n"
add+="\paragraph{}\n"
add+="they igon vector value pairs are\n"
for x in range(len(egonval[0])):
	vac2=[""]*len(egonval[0])
	for y in range(len(egonval[0])):
		vac2[y]=egonval[1][y][x]
	add+="$$"+str(egonval[0][x])+"+"+latex(Matrix(vac2))+"$$"
	add+="\paragraph{}\n"
add+="\paragraph{}\n"


add+="\paragraph{}\n"
add+="the obtained awser would be \n"
add+="\paragraph{}\n"

#input("contue")


f_1_1mat=sol_f_1_l_F(number_of_floors,egonval)
f_1_1mat2=sol_f_1rows_l_F(number_of_floors,egonval)
add+="\paragraph{}\n"
add+="$$fl_{1}=\sum_{1}^{"+str(number_of_floors)+"}fl_{1,n}$$"
add+="\paragraph{}\n"

for x in range(number_of_floors):
	add+="$$"+"\\vec{fl_{1,"+str(x+1)+"}}"+" = "+latex(f_1_1mat2[x][1])+"*"+latex(f_1_1mat2[x][0])+"$$\n"

if input("print f_1_1 y or n").lower()=="y":
	for x in range(len(f_1_1mat)):
		#print("f_1_1",str(x+1),"=")
		#print(f_1_1mat[x])
		pass
invA=get_invA_F(evl_matrix)
egonval=get_egonvalA_F(evl_matrix)



add+="\paragraph{}\n"
add+="\paragraph{}\n"
add+="\paragraph{}\n"
add+="this is where i would put the particular power series and how how to solve with it and explain how there used to solve\n"
add+="\paragraph{}\n"

powerseries=get_powerseries_F(number_of_floors,powervec)

solve=get_powerseries_F(number_of_floors,powervec)

powerF_2_1mat=[""]*len(solve)
mult=len(solve)




for x in range(len(solve)):
	powerF_2_1mat[mult-x-1]=np.dot(solve[mult-x-1],invA)
	if (mult-x-3)>=0:
		solve[mult-x-3]=solve[mult-x-1]+powerF_2_1mat[mult-x-1]*((mult-x-2)*(mult-x-1))





add+="the soltion of the power seres is found with the recusive eqation"
add+="$$A^{-1}*(\\vec{f_{n}}+(n(n+1))*\\vec{fl_{n+2}})=fl_{n}$$\n"
add+="\paragraph{}\n"
add+="this is 3rd order vecor of the power sires"

f_2_l_taylor=powerfunc_F(powerF_2_1mat)
f_2_l_taylor2=Matrix(powerfunc_F(powerF_2_1mat))
f_2_l_taylor3=Matrix(powerfunc_withmax_F(powerF_2_1mat,3))
pprint(f_1_1mat[x])
#pprint(latex(f_2_l_taylor2))
print()
add+="\paragraph{}\n"
add+="$$"+"\\vec{fl_{2}}"+" = "+latex(f_2_l_taylor3)+"$$\n"
F_t_=[0]*len(f_2_l_taylor)
for x in range(len(f_2_l_taylor)):
	F_t_[x]=f_2_l_taylor[x]+f_1_1mat[x]


#print solotions
fldp=[""]*len(F_t_)
for x in range(len(F_t_)):
	this=diff(F_t_[x], time)
	fldp[x]=diff(this, time)


add+="\paragraph{}\n"
add+="\paragraph{}\n"
add+="\paragraph{}\n"
add+="the sum of the $\\vec{fl_{1}}$ and $\\vec{fl_{2}}$ yilds the soltion vector\n"
add+="$$"+"\\vec{fl}"+" = "+"\\vec{fl_{1}}+\\vec{fl_{2}}"+"$$\n"

add+="\paragraph{}\n"
add+="its gigantic so i wont wright it"

fl=Matrix(F_t_)
cheacker=eval_A_mat.dot(fl)

#pprint(eval_A_mat)
print(fl[0])



print(print(""))
print(cheacker[0])
print()
print(fldp[0])
print()
print(F_t_[0])
#print()
#print(fl[1])
#print()
#print(fl[2])
#print(egonval[0][0])
#print(egonval[1][0])
#pprint(evl_matrix)
#pprint(get_egonvalA_F(evl_matrix))




add+="\end{document}"

file = open("testfile.tex","w")



file.write(add) 


file.close()

print(f_2_l_taylor)