Skip to main content
MathOverflow

Return to Question

deleted 3290 characters in body
Source Link
pie
pie
  • 541
  • 4
  • 19

(the intersection of the angle bisectors of the two opposite angles) I I am allowing self-intersecting polygons in this constructions.

This isI wrote a python code than can calculate $A_n, B_n , C_n ,D_n ,E_n$ given the initial pentagon:

import math


print("Number of pentagons")
n=int(input() )
m=max(n,50)
m= min(m, 200)
from decimal import Decimal
import decimal

decimal.getcontext().prec = m
Decimal(10)**(-m)


# enter your coordinates here
A=[Decimal(0),Decimal(0)]
B=[Decimal(0),Decimal(0)]
C=[Decimal(0),Decimal(0)]
D=[Decimal(0),Decimal(0)]
E=[Decimal(0),Decimal(0)]

print("Enter the coordinates of A_1")
A[0]=Decimal(float (input() ))
A[1]=Decimal(float (input() ))
print("Enter the coordinates of B_1")
B[0]=Decimal(float (input() ))
B[1]=Decimal(float (input() ))
print("Enter the coordinates of C_1")
C[0]=Decimal(float (input() ))
C[1]=Decimal(float (input() ))
print("Enter the coordinates of D_1")
D[0]=Decimal(float (input() ))
D[1]=Decimal(float (input() ))
print("Enter the coordinates of E_1")
E[0]=Decimal(float (input() ))
E[1]=Decimal(float (input() ))
X=[Decimal(0),Decimal(0)]
Y=[Decimal(0),Decimal(0)]
Z=[Decimal(0),Decimal(0)]
W=[Decimal(0),Decimal(0)]
T=[Decimal(0),Decimal(0)]

#defining some useful functions--------------------------------------------
def v(a,b):
    result= [b[0]-a[0], b[1]-a[1]]
    return result 
def crs(a, b):
    result = [-Decimal(0.5)*((Decimal(a[0]*b[1])-Decimal(a[1]*b[0])))]
    return result
def dis(a,b):
    result =[Decimal(math.sqrt((a[0]-b[0])**2+(a[1]-b[1])**2))]
    return result 




for i in range (2,n+1):
    AB= dis(A,B)[0]
    BC= dis(B,C)[0]
    CD= dis(C,D)[0]
    DE= dis(D,E)[0]
    EA= dis(E,A)[0]



    #Here to calculate A_n--------------------------------------------
    x=   CD*crs(v(D,C),v(D,E))[0]
    y=  -CD*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(C,B),v(C,D))[0]
    z=  -CD*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(D,C),v(D,E))[0]
    t=   CD*crs(v(C,B),v(C,D))[0]
    X[0]=(x *B[0]+y*C[0]+z*D[0]+t*E[0])/(x+y+z+t)
    X[1]=(x *B[1]+y*C[1]+z*D[1]+t*E[1])/(x+y+z+t)



    #Here to calculate B_n--------------------------------------------
    x=   DE*crs(v(E,D),v(E,A))[0]
    y=  -DE*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(D,C),v(D,E))[0]
    z=  -DE*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(E,D),v(E,A))[0]
    t=   DE*crs(v(D,C),v(D,E))[0]
    Y[0]=(x *C[0]+y*D[0]+z*E[0]+t*A[0])/(x+y+z+t)
    Y[1]=(x *C[1]+y*D[1]+z*E[1]+t*A[1])/(x+y+z+t)



    #Here to calculate C_n--------------------------------------------
    x=   EA*crs(v(A,E),v(A,B))[0]
    y=  -EA*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(E,D),v(E,A))[0]
    z=  -EA*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(A,E),v(A,B))[0]
    t=   EA*crs(v(E,D),v(E,A))[0]
    Z[0]=(x *D[0]+y*E[0]+z*A[0]+t*B[0])/(x+y+z+t)
    Z[1]=(x *D[1]+y*E[1]+z*A[1]+t*B[1])/(x+y+z+t)



    #Here to calculate D_n--------------------------------------------
    x=   AB*crs(v(B,A),v(B,C))[0]
    y=  -AB*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(A,E),v(A,B))[0]
    z=  -AB*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(B,A),v(B,C))[0]
    t=   AB*crs(v(A,E),v(A,B))[0]
    W[0]=(x *E[0]+y*A[0]+z*B[0]+t*C[0])/(x+y+z+t)
    W[1]=(x *E[1]+y*A[1]+z*B[1]+t*C[1])/(x+y+z+t)



    #Here to calculate E_n--------------------------------------------
    x=   BC*crs(v(C,B),v(C,D))[0]
    y=  -BC*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(B,A),v(B,C))[0]
    z=  -BC*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(C,B),v(C,D))[0]
    t=   BC*crs(v(B,A),v(B,C))[0]
    T[0]=(x *A[0]+y*B[0]+z*C[0]+t*D[0])/(x+y+z+t)
    T[1]=(x *A[1]+y*B[1]+z*C[1]+t*D[1])/(x+y+z+t)



    A=XA[0]=X[0]
    B=YA[1]=X[1]
    C=ZB[0]=Y[0]
    D=WB[1]=Y[1]
    E=TC[0]=Z[0]
    C[1]=Z[1]
    D[0]=W[0]
    D[1]=W[1]
    E[0]=T[0]
    E[1]=T[1]
    print(f"A_{i}= {A}")
    print(f"B_{i}= {B}")
    print(f"C_{i}= {C}")
    print(f"D_{i}= {D}")
    print(f"E_{i}= {E}")
    print("\n")

Another thing that supports the convergence of the series that no matter how many times I used that randomrandom function in python with the sequence the result always converge (suggesting it always converge except some zero measure set )

import math

import random

print("Number of pentagons")
n=int(input() )
m=max(n,50)
m= min(m, 200)
from decimal import Decimal
import decimal

decimal.getcontext().prec = m
Decimal(10)**(-m)


# enter your coordinates here
A=[Decimal(0),Decimal(0)]
B=[Decimal(0),Decimal(0)]
C=[Decimal(0),Decimal(0)]
D=[Decimal(0),Decimal(0)]
E=[Decimal(0),Decimal(0)]


A[0]=Decimal(random.random() )
A[1]=Decimal(random.random())

B[0]=Decimal(random.random())
B[1]=Decimal(random.random())

C[0]=Decimal(random.random())
C[1]=Decimal(random.random())

D[0]=Decimal(random.random())
D[1]=Decimal(random.random())

E[0]=Decimal(random.random())
E[1]=Decimal(random.random())
X=[Decimal(0),Decimal(0)]
Y=[Decimal(0),Decimal(0)]
Z=[Decimal(0),Decimal(0)]
W=[Decimal(0),Decimal(0)]
T=[Decimal(0),Decimal(0)]

#defining some useful functions--------------------------------------------
def v(a,b):
    result= [b[0]-a[0], b[1]-a[1]]
    return result 
def crs(a, b):
    result = [-Decimal(0.5)*((Decimal(a[0]*b[1])-Decimal(a[1]*b[0])))]
    return result
def dis(a,b):
    result =[Decimal(math.sqrt((a[0]-b[0])**2+(a[1]-b[1])**2))]
    return result 




for i in range (2,n+1):
    AB= dis(A,B)[0]
    BC= dis(B,C)[0]
    CD= dis(C,D)[0]
    DE= dis(D,E)[0]
    EA= dis(E,A)[0]



    #Here to calculate A_n--------------------------------------------
    x=   CD*crs(v(D,C),v(D,E))[0]
    y=  -CD*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(C,B),v(C,D))[0]
    z=  -CD*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(D,C),v(D,E))[0]
    t=   CD*crs(v(C,B),v(C,D))[0]
    X[0]=(x *B[0]+y*C[0]+z*D[0]+t*E[0])/(x+y+z+t)
    X[1]=(x *B[1]+y*C[1]+z*D[1]+t*E[1])/(x+y+z+t)



    #Here to calculate B_n--------------------------------------------
    x=   DE*crs(v(E,D),v(E,A))[0]
    y=  -DE*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(D,C),v(D,E))[0]
    z=  -DE*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(E,D),v(E,A))[0]
    t=   DE*crs(v(D,C),v(D,E))[0]
    Y[0]=(x *C[0]+y*D[0]+z*E[0]+t*A[0])/(x+y+z+t)
    Y[1]=(x *C[1]+y*D[1]+z*E[1]+t*A[1])/(x+y+z+t)



    #Here to calculate C_n--------------------------------------------
    x=   EA*crs(v(A,E),v(A,B))[0]
    y=  -EA*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(E,D),v(E,A))[0]
    z=  -EA*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(A,E),v(A,B))[0]
    t=   EA*crs(v(E,D),v(E,A))[0]
    Z[0]=(x *D[0]+y*E[0]+z*A[0]+t*B[0])/(x+y+z+t)
    Z[1]=(x *D[1]+y*E[1]+z*A[1]+t*B[1])/(x+y+z+t)



    #Here to calculate D_n--------------------------------------------
    x=   AB*crs(v(B,A),v(B,C))[0]
    y=  -AB*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(A,E),v(A,B))[0]
    z=  -AB*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(B,A),v(B,C))[0]
    t=   AB*crs(v(A,E),v(A,B))[0]
    W[0]=(x *E[0]+y*A[0]+z*B[0]+t*C[0])/(x+y+z+t)
    W[1]=(x *E[1]+y*A[1]+z*B[1]+t*C[1])/(x+y+z+t)



    #Here to calculate E_n--------------------------------------------
    x=   BC*crs(v(C,B),v(C,D))[0]
    y=  -BC*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(B,A),v(B,C))[0]
    z=  -BC*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(C,B),v(C,D))[0]
    t=   BC*crs(v(B,A),v(B,C))[0]
    T[0]=(x *A[0]+y*B[0]+z*C[0]+t*D[0])/(x+y+z+t)
    T[1]=(x *A[1]+y*B[1]+z*C[1]+t*D[1])/(x+y+z+t)



    A=X
    B=Y
    C=Z
    D=W
    E=T
    print(f"A_{i}= {A}")
    print(f"B_{i}= {B}")
    print(f"C_{i}= {C}")
    print(f"D_{i}= {D}")
    print(f"E_{i}= {E}")
    print("\n")

(the two opposite angles) I am allowing self-intersecting polygons in this constructions.

This is a python code than can calculate $A_n, B_n , C_n ,D_n ,E_n$

import math


print("Number of pentagons")
n=int(input() )
m=max(n,50)
m= min(m, 200)
from decimal import Decimal
import decimal

decimal.getcontext().prec = m
Decimal(10)**(-m)


# enter your coordinates here
A=[Decimal(0),Decimal(0)]
B=[Decimal(0),Decimal(0)]
C=[Decimal(0),Decimal(0)]
D=[Decimal(0),Decimal(0)]
E=[Decimal(0),Decimal(0)]

print("Enter the coordinates of A_1")
A[0]=Decimal(float (input() ))
A[1]=Decimal(float (input() ))
print("Enter the coordinates of B_1")
B[0]=Decimal(float (input() ))
B[1]=Decimal(float (input() ))
print("Enter the coordinates of C_1")
C[0]=Decimal(float (input() ))
C[1]=Decimal(float (input() ))
print("Enter the coordinates of D_1")
D[0]=Decimal(float (input() ))
D[1]=Decimal(float (input() ))
print("Enter the coordinates of E_1")
E[0]=Decimal(float (input() ))
E[1]=Decimal(float (input() ))
X=[Decimal(0),Decimal(0)]
Y=[Decimal(0),Decimal(0)]
Z=[Decimal(0),Decimal(0)]
W=[Decimal(0),Decimal(0)]
T=[Decimal(0),Decimal(0)]

#defining some useful functions--------------------------------------------
def v(a,b):
    result= [b[0]-a[0], b[1]-a[1]]
    return result 
def crs(a, b):
    result = [-Decimal(0.5)*((Decimal(a[0]*b[1])-Decimal(a[1]*b[0])))]
    return result
def dis(a,b):
    result =[Decimal(math.sqrt((a[0]-b[0])**2+(a[1]-b[1])**2))]
    return result 




for i in range (2,n+1):
    AB= dis(A,B)[0]
    BC= dis(B,C)[0]
    CD= dis(C,D)[0]
    DE= dis(D,E)[0]
    EA= dis(E,A)[0]



    #Here to calculate A_n--------------------------------------------
    x=   CD*crs(v(D,C),v(D,E))[0]
    y=  -CD*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(C,B),v(C,D))[0]
    z=  -CD*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(D,C),v(D,E))[0]
    t=   CD*crs(v(C,B),v(C,D))[0]
    X[0]=(x *B[0]+y*C[0]+z*D[0]+t*E[0])/(x+y+z+t)
    X[1]=(x *B[1]+y*C[1]+z*D[1]+t*E[1])/(x+y+z+t)



    #Here to calculate B_n--------------------------------------------
    x=   DE*crs(v(E,D),v(E,A))[0]
    y=  -DE*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(D,C),v(D,E))[0]
    z=  -DE*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(E,D),v(E,A))[0]
    t=   DE*crs(v(D,C),v(D,E))[0]
    Y[0]=(x *C[0]+y*D[0]+z*E[0]+t*A[0])/(x+y+z+t)
    Y[1]=(x *C[1]+y*D[1]+z*E[1]+t*A[1])/(x+y+z+t)



    #Here to calculate C_n--------------------------------------------
    x=   EA*crs(v(A,E),v(A,B))[0]
    y=  -EA*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(E,D),v(E,A))[0]
    z=  -EA*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(A,E),v(A,B))[0]
    t=   EA*crs(v(E,D),v(E,A))[0]
    Z[0]=(x *D[0]+y*E[0]+z*A[0]+t*B[0])/(x+y+z+t)
    Z[1]=(x *D[1]+y*E[1]+z*A[1]+t*B[1])/(x+y+z+t)



    #Here to calculate D_n--------------------------------------------
    x=   AB*crs(v(B,A),v(B,C))[0]
    y=  -AB*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(A,E),v(A,B))[0]
    z=  -AB*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(B,A),v(B,C))[0]
    t=   AB*crs(v(A,E),v(A,B))[0]
    W[0]=(x *E[0]+y*A[0]+z*B[0]+t*C[0])/(x+y+z+t)
    W[1]=(x *E[1]+y*A[1]+z*B[1]+t*C[1])/(x+y+z+t)



    #Here to calculate E_n--------------------------------------------
    x=   BC*crs(v(C,B),v(C,D))[0]
    y=  -BC*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(B,A),v(B,C))[0]
    z=  -BC*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(C,B),v(C,D))[0]
    t=   BC*crs(v(B,A),v(B,C))[0]
    T[0]=(x *A[0]+y*B[0]+z*C[0]+t*D[0])/(x+y+z+t)
    T[1]=(x *A[1]+y*B[1]+z*C[1]+t*D[1])/(x+y+z+t)



    A=X
    B=Y
    C=Z
    D=W
    E=T
    print(f"A_{i}= {A}")
    print(f"B_{i}= {B}")
    print(f"C_{i}= {C}")
    print(f"D_{i}= {D}")
    print(f"E_{i}= {E}")
    print("\n")

Another thing that supports the convergence of the series that no matter how many times I used that random function in python with the sequence the result always converge (suggesting it always converge except some zero measure set )

import math

import random

print("Number of pentagons")
n=int(input() )
m=max(n,50)
m= min(m, 200)
from decimal import Decimal
import decimal

decimal.getcontext().prec = m
Decimal(10)**(-m)


# enter your coordinates here
A=[Decimal(0),Decimal(0)]
B=[Decimal(0),Decimal(0)]
C=[Decimal(0),Decimal(0)]
D=[Decimal(0),Decimal(0)]
E=[Decimal(0),Decimal(0)]


A[0]=Decimal(random.random() )
A[1]=Decimal(random.random())

B[0]=Decimal(random.random())
B[1]=Decimal(random.random())

C[0]=Decimal(random.random())
C[1]=Decimal(random.random())

D[0]=Decimal(random.random())
D[1]=Decimal(random.random())

E[0]=Decimal(random.random())
E[1]=Decimal(random.random())
X=[Decimal(0),Decimal(0)]
Y=[Decimal(0),Decimal(0)]
Z=[Decimal(0),Decimal(0)]
W=[Decimal(0),Decimal(0)]
T=[Decimal(0),Decimal(0)]

#defining some useful functions--------------------------------------------
def v(a,b):
    result= [b[0]-a[0], b[1]-a[1]]
    return result 
def crs(a, b):
    result = [-Decimal(0.5)*((Decimal(a[0]*b[1])-Decimal(a[1]*b[0])))]
    return result
def dis(a,b):
    result =[Decimal(math.sqrt((a[0]-b[0])**2+(a[1]-b[1])**2))]
    return result 




for i in range (2,n+1):
    AB= dis(A,B)[0]
    BC= dis(B,C)[0]
    CD= dis(C,D)[0]
    DE= dis(D,E)[0]
    EA= dis(E,A)[0]



    #Here to calculate A_n--------------------------------------------
    x=   CD*crs(v(D,C),v(D,E))[0]
    y=  -CD*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(C,B),v(C,D))[0]
    z=  -CD*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(D,C),v(D,E))[0]
    t=   CD*crs(v(C,B),v(C,D))[0]
    X[0]=(x *B[0]+y*C[0]+z*D[0]+t*E[0])/(x+y+z+t)
    X[1]=(x *B[1]+y*C[1]+z*D[1]+t*E[1])/(x+y+z+t)



    #Here to calculate B_n--------------------------------------------
    x=   DE*crs(v(E,D),v(E,A))[0]
    y=  -DE*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(D,C),v(D,E))[0]
    z=  -DE*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(E,D),v(E,A))[0]
    t=   DE*crs(v(D,C),v(D,E))[0]
    Y[0]=(x *C[0]+y*D[0]+z*E[0]+t*A[0])/(x+y+z+t)
    Y[1]=(x *C[1]+y*D[1]+z*E[1]+t*A[1])/(x+y+z+t)



    #Here to calculate C_n--------------------------------------------
    x=   EA*crs(v(A,E),v(A,B))[0]
    y=  -EA*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(E,D),v(E,A))[0]
    z=  -EA*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(A,E),v(A,B))[0]
    t=   EA*crs(v(E,D),v(E,A))[0]
    Z[0]=(x *D[0]+y*E[0]+z*A[0]+t*B[0])/(x+y+z+t)
    Z[1]=(x *D[1]+y*E[1]+z*A[1]+t*B[1])/(x+y+z+t)



    #Here to calculate D_n--------------------------------------------
    x=   AB*crs(v(B,A),v(B,C))[0]
    y=  -AB*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(A,E),v(A,B))[0]
    z=  -AB*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(B,A),v(B,C))[0]
    t=   AB*crs(v(A,E),v(A,B))[0]
    W[0]=(x *E[0]+y*A[0]+z*B[0]+t*C[0])/(x+y+z+t)
    W[1]=(x *E[1]+y*A[1]+z*B[1]+t*C[1])/(x+y+z+t)



    #Here to calculate E_n--------------------------------------------
    x=   BC*crs(v(C,B),v(C,D))[0]
    y=  -BC*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(B,A),v(B,C))[0]
    z=  -BC*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(C,B),v(C,D))[0]
    t=   BC*crs(v(B,A),v(B,C))[0]
    T[0]=(x *A[0]+y*B[0]+z*C[0]+t*D[0])/(x+y+z+t)
    T[1]=(x *A[1]+y*B[1]+z*C[1]+t*D[1])/(x+y+z+t)



    A=X
    B=Y
    C=Z
    D=W
    E=T
    print(f"A_{i}= {A}")
    print(f"B_{i}= {B}")
    print(f"C_{i}= {C}")
    print(f"D_{i}= {D}")
    print(f"E_{i}= {E}")
    print("\n")

(the intersection of the angle bisectors of the two opposite angles) I am allowing self-intersecting polygons in this constructions.

I wrote a python code than can calculate $A_n, B_n , C_n ,D_n ,E_n$ given the initial pentagon:

import math


print("Number of pentagons")
n=int(input())
m=max(n,50)
from decimal import Decimal
import decimal

decimal.getcontext().prec = m
Decimal(10)**(-m)


# enter your coordinates here
A=[Decimal(0),Decimal(0)]
B=[Decimal(0),Decimal(0)]
C=[Decimal(0),Decimal(0)]
D=[Decimal(0),Decimal(0)]
E=[Decimal(0),Decimal(0)]

print("Enter the coordinates of A_1")
A[0]=Decimal(float (input() ))
A[1]=Decimal(float (input() ))
print("Enter the coordinates of B_1")
B[0]=Decimal(float (input() ))
B[1]=Decimal(float (input() ))
print("Enter the coordinates of C_1")
C[0]=Decimal(float (input() ))
C[1]=Decimal(float (input() ))
print("Enter the coordinates of D_1")
D[0]=Decimal(float (input() ))
D[1]=Decimal(float (input() ))
print("Enter the coordinates of E_1")
E[0]=Decimal(float (input() ))
E[1]=Decimal(float (input() ))
X=[Decimal(0),Decimal(0)]
Y=[Decimal(0),Decimal(0)]
Z=[Decimal(0),Decimal(0)]
W=[Decimal(0),Decimal(0)]
T=[Decimal(0),Decimal(0)]

#defining some useful functions--------------------------------------------
def v(a,b):
    result= [b[0]-a[0], b[1]-a[1]]
    return result 
def crs(a, b):
    result = [-Decimal(0.5)*((Decimal(a[0]*b[1])-Decimal(a[1]*b[0])))]
    return result
def dis(a,b):
    result =[Decimal(math.sqrt((a[0]-b[0])**2+(a[1]-b[1])**2))]
    return result 




for i in range (2,n+1):
    AB= dis(A,B)[0]
    BC= dis(B,C)[0]
    CD= dis(C,D)[0]
    DE= dis(D,E)[0]
    EA= dis(E,A)[0]



    #Here to calculate A_n--------------------------------------------
    x=   CD*crs(v(D,C),v(D,E))[0]
    y=  -CD*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(C,B),v(C,D))[0]
    z=  -CD*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(D,C),v(D,E))[0]
    t=   CD*crs(v(C,B),v(C,D))[0]
    X[0]=(x *B[0]+y*C[0]+z*D[0]+t*E[0])/(x+y+z+t)
    X[1]=(x *B[1]+y*C[1]+z*D[1]+t*E[1])/(x+y+z+t)



    #Here to calculate B_n--------------------------------------------
    x=   DE*crs(v(E,D),v(E,A))[0]
    y=  -DE*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(D,C),v(D,E))[0]
    z=  -DE*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(E,D),v(E,A))[0]
    t=   DE*crs(v(D,C),v(D,E))[0]
    Y[0]=(x *C[0]+y*D[0]+z*E[0]+t*A[0])/(x+y+z+t)
    Y[1]=(x *C[1]+y*D[1]+z*E[1]+t*A[1])/(x+y+z+t)



    #Here to calculate C_n--------------------------------------------
    x=   EA*crs(v(A,E),v(A,B))[0]
    y=  -EA*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(E,D),v(E,A))[0]
    z=  -EA*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(A,E),v(A,B))[0]
    t=   EA*crs(v(E,D),v(E,A))[0]
    Z[0]=(x *D[0]+y*E[0]+z*A[0]+t*B[0])/(x+y+z+t)
    Z[1]=(x *D[1]+y*E[1]+z*A[1]+t*B[1])/(x+y+z+t)



    #Here to calculate D_n--------------------------------------------
    x=   AB*crs(v(B,A),v(B,C))[0]
    y=  -AB*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(A,E),v(A,B))[0]
    z=  -AB*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(B,A),v(B,C))[0]
    t=   AB*crs(v(A,E),v(A,B))[0]
    W[0]=(x *E[0]+y*A[0]+z*B[0]+t*C[0])/(x+y+z+t)
    W[1]=(x *E[1]+y*A[1]+z*B[1]+t*C[1])/(x+y+z+t)



    #Here to calculate E_n--------------------------------------------
    x=   BC*crs(v(C,B),v(C,D))[0]
    y=  -BC*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(B,A),v(B,C))[0]
    z=  -BC*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(C,B),v(C,D))[0]
    t=   BC*crs(v(B,A),v(B,C))[0]
    T[0]=(x *A[0]+y*B[0]+z*C[0]+t*D[0])/(x+y+z+t)
    T[1]=(x *A[1]+y*B[1]+z*C[1]+t*D[1])/(x+y+z+t)



    A[0]=X[0]
    A[1]=X[1]
    B[0]=Y[0]
    B[1]=Y[1]
    C[0]=Z[0]
    C[1]=Z[1]
    D[0]=W[0]
    D[1]=W[1]
    E[0]=T[0]
    E[1]=T[1]
    print(f"A_{i}= {A}")
    print(f"B_{i}= {B}")
    print(f"C_{i}= {C}")
    print(f"D_{i}= {D}")
    print(f"E_{i}= {E}")
    print("\n")

Another thing that supports the convergence of the series that no matter how many times I used that random function in python with the sequence the result always converge (suggesting it always converge except some zero measure set )

Notice removed Draw attention by CommunityBot
Bounty Ended with Max H. Weinreich's answer chosen by CommunityBot
added 4957 characters in body
Source Link
pie
pie
  • 541
  • 4
  • 19
import math


print("Number of pentagons")
n=int(input() )
m=max(n,50)
m= min(m, 200)
from decimal import Decimal
import decimal

decimal.getcontext().prec = m
Decimal(10)**(-m)


# enter your coordinates here
A=[0A=[Decimal(0),0]Decimal(0)]
B=[1B=[Decimal(0),1]Decimal(0)]
C=[3C=[Decimal(0),5]Decimal(0)]
D=[2D=[Decimal(0),7]Decimal(0)]
E=[2E=[Decimal(0),6]Decimal(0)]

X=[0print("Enter the coordinates of A_1")
A[0]=Decimal(float (input() ))
A[1]=Decimal(float (input() ))
print("Enter the coordinates of B_1")
B[0]=Decimal(float (input() ))
B[1]=Decimal(float (input() ))
print("Enter the coordinates of C_1")
C[0]=Decimal(float (input() ))
C[1]=Decimal(float (input() ))
print("Enter the coordinates of D_1")
D[0]=Decimal(float (input() ))
D[1]=Decimal(float (input() ))
print("Enter the coordinates of E_1")
E[0]=Decimal(float (input() ))
E[1]=Decimal(float (input() ))
X=[Decimal(0),0]Decimal(0)]
Y=[0Y=[Decimal(0),0]Decimal(0)]
Z=[0Z=[Decimal(0),0]Decimal(0)]
W=[0W=[Decimal(0),0]Decimal(0)]
T=[0T=[Decimal(0),0]Decimal(0)]

#defining some useful functions--------------------------------------------
def v(a,b):
    result= [b[0]-a[0], b[1]-a[1]]

     return result 
def crs(a, b):
    result = [-Decimal(0.5)*((Decimal(a[0]*b[1])-Decimal(a[1]*b[0])))]
    return result
def dis(a,b):
    result =[Decimal(math.sqrt((a[0]-b[0])**2+(a[1]-b[1])**2))]
    return result 


def crs(a, b):
    result = [-0.5*((a[0]*b[1])-(a[1]*b[0]))]


for i in range return(2,n+1):
 result   AB= dis(A,B)[0]
    BC= dis(B,C)[0]
    CD= dis(C,D)[0]
    DE= dis(D,E)[0]
    EA= dis(E,A)[0]



    #Here to calculate A_n--------------------------------------------
    x=   CD*crs(v(D,C),v(D,E))[0]
    y=  -CD*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(C,B),v(C,D))[0]
    z=  -CD*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(D,C),v(D,E))[0]
    t=   CD*crs(v(C,B),v(C,D))[0]
    X[0]=(x *B[0]+y*C[0]+z*D[0]+t*E[0])/(x+y+z+t)
    X[1]=(x *B[1]+y*C[1]+z*D[1]+t*E[1])/(x+y+z+t)



    #Here to calculate B_n--------------------------------------------
    x=   DE*crs(v(E,D),v(E,A))[0]
    y=  -DE*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(D,C),v(D,E))[0]
    z=  -DE*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(E,D),v(E,A))[0]
    t=   DE*crs(v(D,C),v(D,E))[0]
    Y[0]=(x *C[0]+y*D[0]+z*E[0]+t*A[0])/(x+y+z+t)
    Y[1]=(x *C[1]+y*D[1]+z*E[1]+t*A[1])/(x+y+z+t)



    #Here to calculate C_n--------------------------------------------
    x=   EA*crs(v(A,E),v(A,B))[0]
    y=  -EA*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(E,D),v(E,A))[0]
    z=  -EA*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(A,E),v(A,B))[0]
    t=   EA*crs(v(E,D),v(E,A))[0]
    Z[0]=(x *D[0]+y*E[0]+z*A[0]+t*B[0])/(x+y+z+t)
    Z[1]=(x *D[1]+y*E[1]+z*A[1]+t*B[1])/(x+y+z+t)



    #Here to calculate D_n--------------------------------------------
    x=   AB*crs(v(B,A),v(B,C))[0]
    y=  -AB*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(A,E),v(A,B))[0]
    z=  -AB*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(B,A),v(B,C))[0]
    t=   AB*crs(v(A,E),v(A,B))[0]
    W[0]=(x *E[0]+y*A[0]+z*B[0]+t*C[0])/(x+y+z+t)
    W[1]=(x *E[1]+y*A[1]+z*B[1]+t*C[1])/(x+y+z+t)



    #Here to calculate E_n--------------------------------------------
    x=   BC*crs(v(C,B),v(C,D))[0]
    y=  -BC*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(B,A),v(B,C))[0]
    z=  -BC*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(C,B),v(C,D))[0]
    t=   BC*crs(v(B,A),v(B,C))[0]
    T[0]=(x *A[0]+y*B[0]+z*C[0]+t*D[0])/(x+y+z+t)
    T[1]=(x *A[1]+y*B[1]+z*C[1]+t*D[1])/(x+y+z+t)



    A=X
    B=Y
    C=Z
    D=W
    E=T
    print(f"A_{i}= {A}")
    print(f"B_{i}= {B}")
    print(f"C_{i}= {C}")
    print(f"D_{i}= {D}")
    print(f"E_{i}= {E}")
    print("\n")

Another thing that supports the convergence of the series that no matter how many times I used that random function in python with the sequence the result always converge (suggesting it always converge except some zero measure set )

import math

import random

print("Number of pentagons")
n=int(input() )
m=max(n,50)
m= min(m, 200)
from decimal import Decimal
import decimal

decimal.getcontext().prec = m
Decimal(10)**(-m)


# enter your coordinates here
A=[Decimal(0),Decimal(0)]
B=[Decimal(0),Decimal(0)]
C=[Decimal(0),Decimal(0)]
D=[Decimal(0),Decimal(0)]
E=[Decimal(0),Decimal(0)]


A[0]=Decimal(random.random() )
A[1]=Decimal(random.random())

B[0]=Decimal(random.random())
B[1]=Decimal(random.random())

C[0]=Decimal(random.random())
C[1]=Decimal(random.random())

D[0]=Decimal(random.random())
D[1]=Decimal(random.random())

E[0]=Decimal(random.random())
E[1]=Decimal(random.random())
X=[Decimal(0),Decimal(0)]
Y=[Decimal(0),Decimal(0)]
Z=[Decimal(0),Decimal(0)]
W=[Decimal(0),Decimal(0)]
T=[Decimal(0),Decimal(0)]

#defining some useful functions--------------------------------------------
def v(a,b):
    result= [b[0]-a[0], b[1]-a[1]]
    return result 
def crs(a, b):
    result = [-Decimal(0.5)*((Decimal(a[0]*b[1])-Decimal(a[1]*b[0])))]
    return result
def dis(a,b):
    result =[math=[Decimal(math.sqrt((a[0]-b[0])**2+(a[1]-b[1])**2))]
    return result 


 

for i in range (2,100+1n+1):
    AB= dis(A,B)[0]
    BC= dis(B,C)[0]
    CD= dis(C,D)[0]
    DE= dis(D,E)[0]
    EA= dis(E,A)[0]



    #Here to calculate A_n--------------------------------------------
    x=   CD*crs(v(D,C),v(D,E))[0]
    y=  -CD*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(C,B),v(C,D))[0]
    z=  -CD*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(D,C),v(D,E))[0]
    t=   CD*crs(v(C,B),v(C,D))[0]
    X[0]=(x *B[0]+y*C[0]+z*D[0]+t*E[0])/(x+y+z+t)
    X[1]=(x *B[1]+y*C[1]+z*D[1]+t*E[1])/(x+y+z+t)



    #Here to calculate B_n--------------------------------------------
    x=   DE*crs(v(E,D),v(E,A))[0]
    y=  -DE*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(D,C),v(D,E))[0]
    z=  -DE*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(E,D),v(E,A))[0]
    t=   DE*crs(v(D,C),v(D,E))[0]
    Y[0]=(x *C[0]+y*D[0]+z*E[0]+t*A[0])/(x+y+z+t)
    Y[1]=(x *C[1]+y*D[1]+z*E[1]+t*A[1])/(x+y+z+t)



    #Here to calculate C_n--------------------------------------------
    x=   EA*crs(v(A,E),v(A,B))[0]
    y=  -EA*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(E,D),v(E,A))[0]
    z=  -EA*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(A,E),v(A,B))[0]
    t=   EA*crs(v(E,D),v(E,A))[0]
    Z[0]=(x *D[0]+y*E[0]+z*A[0]+t*B[0])/(x+y+z+t)
    Z[1]=(x *D[1]+y*E[1]+z*A[1]+t*B[1])/(x+y+z+t)



    #Here to calculate D_n--------------------------------------------
    x=   AB*crs(v(B,A),v(B,C))[0]
    y=  -AB*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(A,E),v(A,B))[0]
    z=  -AB*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(B,A),v(B,C))[0]
    t=   AB*crs(v(A,E),v(A,B))[0]
    W[0]=(x *E[0]+y*A[0]+z*B[0]+t*C[0])/(x+y+z+t)
    W[1]=(x *E[1]+y*A[1]+z*B[1]+t*C[1])/(x+y+z+t)



    #Here to calculate E_n--------------------------------------------
    x=   BC*crs(v(C,B),v(C,D))[0]
    y=  -BC*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(B,A),v(B,C))[0]
    z=  -BC*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(C,B),v(C,D))[0]
    t=   BC*crs(v(B,A),v(B,C))[0]
    T[0]=(x *A[0]+y*B[0]+z*C[0]+t*D[0])/(x+y+z+t)
    T[1]=(x *A[1]+y*B[1]+z*C[1]+t*D[1])/(x+y+z+t)
 


    A=X
    B=Y
    C=Z
    D=W
    E=T

    
    print(f"A_{i}= {A}")
    print(f"B_{i}= {B}")
    print(f"C_{i}= {C}")
    print(f"D_{i}= {D}")
    print(f"E_{i}= {E}")
    print("\n")

import math 
# enter your coordinates here
A=[0,0]
B=[1,1]
C=[3,5]
D=[2,7]
E=[2,6]

X=[0,0]
Y=[0,0]
Z=[0,0]
W=[0,0]
T=[0,0]

def v(a,b):
    result= [b[0]-a[0], b[1]-a[1]]

     return result 


def crs(a, b):
    result = [-0.5*((a[0]*b[1])-(a[1]*b[0]))]

    return result


def dis(a,b):
    result =[math.sqrt((a[0]-b[0])**2+(a[1]-b[1])**2)]
    return result 


for i in range (2,100+1):
    AB= dis(A,B)[0]
    BC= dis(B,C)[0]
    CD= dis(C,D)[0]
    DE= dis(D,E)[0]
    EA= dis(E,A)[0]



    #Here to calculate A_n
    x=   CD*crs(v(D,C),v(D,E))[0]
    y=  -CD*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(C,B),v(C,D))[0]
    z=  -CD*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(D,C),v(D,E))[0]
    t=   CD*crs(v(C,B),v(C,D))[0]
    X[0]=(x *B[0]+y*C[0]+z*D[0]+t*E[0])/(x+y+z+t)
    X[1]=(x *B[1]+y*C[1]+z*D[1]+t*E[1])/(x+y+z+t)



    #Here to calculate B_n
    x=   DE*crs(v(E,D),v(E,A))[0]
    y=  -DE*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(D,C),v(D,E))[0]
    z=  -DE*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(E,D),v(E,A))[0]
    t=   DE*crs(v(D,C),v(D,E))[0]
    Y[0]=(x *C[0]+y*D[0]+z*E[0]+t*A[0])/(x+y+z+t)
    Y[1]=(x *C[1]+y*D[1]+z*E[1]+t*A[1])/(x+y+z+t)



    #Here to calculate C_n
    x=   EA*crs(v(A,E),v(A,B))[0]
    y=  -EA*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(E,D),v(E,A))[0]
    z=  -EA*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(A,E),v(A,B))[0]
    t=   EA*crs(v(E,D),v(E,A))[0]
    Z[0]=(x *D[0]+y*E[0]+z*A[0]+t*B[0])/(x+y+z+t)
    Z[1]=(x *D[1]+y*E[1]+z*A[1]+t*B[1])/(x+y+z+t)



    #Here to calculate D_n
    x=   AB*crs(v(B,A),v(B,C))[0]
    y=  -AB*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(A,E),v(A,B))[0]
    z=  -AB*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(B,A),v(B,C))[0]
    t=   AB*crs(v(A,E),v(A,B))[0]
    W[0]=(x *E[0]+y*A[0]+z*B[0]+t*C[0])/(x+y+z+t)
    W[1]=(x *E[1]+y*A[1]+z*B[1]+t*C[1])/(x+y+z+t)



    #Here to calculate E_n
    x=   BC*crs(v(C,B),v(C,D))[0]
    y=  -BC*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(B,A),v(B,C))[0]
    z=  -BC*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(C,B),v(C,D))[0]
    t=   BC*crs(v(B,A),v(B,C))[0]
    T[0]=(x *A[0]+y*B[0]+z*C[0]+t*D[0])/(x+y+z+t)
    T[1]=(x *A[1]+y*B[1]+z*C[1]+t*D[1])/(x+y+z+t)
    A=X
    B=Y
    C=Z
    D=W
    E=T

    
    print(f"A_{i}= {A}")
    print(f"B_{i}= {B}")
    print(f"C_{i}= {C}")
    print(f"D_{i}= {D}")
    print(f"E_{i}= {E}")

import math


print("Number of pentagons")
n=int(input() )
m=max(n,50)
m= min(m, 200)
from decimal import Decimal
import decimal

decimal.getcontext().prec = m
Decimal(10)**(-m)


# enter your coordinates here
A=[Decimal(0),Decimal(0)]
B=[Decimal(0),Decimal(0)]
C=[Decimal(0),Decimal(0)]
D=[Decimal(0),Decimal(0)]
E=[Decimal(0),Decimal(0)]

print("Enter the coordinates of A_1")
A[0]=Decimal(float (input() ))
A[1]=Decimal(float (input() ))
print("Enter the coordinates of B_1")
B[0]=Decimal(float (input() ))
B[1]=Decimal(float (input() ))
print("Enter the coordinates of C_1")
C[0]=Decimal(float (input() ))
C[1]=Decimal(float (input() ))
print("Enter the coordinates of D_1")
D[0]=Decimal(float (input() ))
D[1]=Decimal(float (input() ))
print("Enter the coordinates of E_1")
E[0]=Decimal(float (input() ))
E[1]=Decimal(float (input() ))
X=[Decimal(0),Decimal(0)]
Y=[Decimal(0),Decimal(0)]
Z=[Decimal(0),Decimal(0)]
W=[Decimal(0),Decimal(0)]
T=[Decimal(0),Decimal(0)]

#defining some useful functions--------------------------------------------
def v(a,b):
    result= [b[0]-a[0], b[1]-a[1]]
    return result 
def crs(a, b):
    result = [-Decimal(0.5)*((Decimal(a[0]*b[1])-Decimal(a[1]*b[0])))]
    return result
def dis(a,b):
    result =[Decimal(math.sqrt((a[0]-b[0])**2+(a[1]-b[1])**2))]
    return result 




for i in range (2,n+1):
    AB= dis(A,B)[0]
    BC= dis(B,C)[0]
    CD= dis(C,D)[0]
    DE= dis(D,E)[0]
    EA= dis(E,A)[0]



    #Here to calculate A_n--------------------------------------------
    x=   CD*crs(v(D,C),v(D,E))[0]
    y=  -CD*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(C,B),v(C,D))[0]
    z=  -CD*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(D,C),v(D,E))[0]
    t=   CD*crs(v(C,B),v(C,D))[0]
    X[0]=(x *B[0]+y*C[0]+z*D[0]+t*E[0])/(x+y+z+t)
    X[1]=(x *B[1]+y*C[1]+z*D[1]+t*E[1])/(x+y+z+t)



    #Here to calculate B_n--------------------------------------------
    x=   DE*crs(v(E,D),v(E,A))[0]
    y=  -DE*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(D,C),v(D,E))[0]
    z=  -DE*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(E,D),v(E,A))[0]
    t=   DE*crs(v(D,C),v(D,E))[0]
    Y[0]=(x *C[0]+y*D[0]+z*E[0]+t*A[0])/(x+y+z+t)
    Y[1]=(x *C[1]+y*D[1]+z*E[1]+t*A[1])/(x+y+z+t)



    #Here to calculate C_n--------------------------------------------
    x=   EA*crs(v(A,E),v(A,B))[0]
    y=  -EA*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(E,D),v(E,A))[0]
    z=  -EA*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(A,E),v(A,B))[0]
    t=   EA*crs(v(E,D),v(E,A))[0]
    Z[0]=(x *D[0]+y*E[0]+z*A[0]+t*B[0])/(x+y+z+t)
    Z[1]=(x *D[1]+y*E[1]+z*A[1]+t*B[1])/(x+y+z+t)



    #Here to calculate D_n--------------------------------------------
    x=   AB*crs(v(B,A),v(B,C))[0]
    y=  -AB*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(A,E),v(A,B))[0]
    z=  -AB*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(B,A),v(B,C))[0]
    t=   AB*crs(v(A,E),v(A,B))[0]
    W[0]=(x *E[0]+y*A[0]+z*B[0]+t*C[0])/(x+y+z+t)
    W[1]=(x *E[1]+y*A[1]+z*B[1]+t*C[1])/(x+y+z+t)



    #Here to calculate E_n--------------------------------------------
    x=   BC*crs(v(C,B),v(C,D))[0]
    y=  -BC*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(B,A),v(B,C))[0]
    z=  -BC*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(C,B),v(C,D))[0]
    t=   BC*crs(v(B,A),v(B,C))[0]
    T[0]=(x *A[0]+y*B[0]+z*C[0]+t*D[0])/(x+y+z+t)
    T[1]=(x *A[1]+y*B[1]+z*C[1]+t*D[1])/(x+y+z+t)



    A=X
    B=Y
    C=Z
    D=W
    E=T
    print(f"A_{i}= {A}")
    print(f"B_{i}= {B}")
    print(f"C_{i}= {C}")
    print(f"D_{i}= {D}")
    print(f"E_{i}= {E}")
    print("\n")

Another thing that supports the convergence of the series that no matter how many times I used that random function in python with the sequence the result always converge (suggesting it always converge except some zero measure set )

import math

import random

print("Number of pentagons")
n=int(input() )
m=max(n,50)
m= min(m, 200)
from decimal import Decimal
import decimal

decimal.getcontext().prec = m
Decimal(10)**(-m)


# enter your coordinates here
A=[Decimal(0),Decimal(0)]
B=[Decimal(0),Decimal(0)]
C=[Decimal(0),Decimal(0)]
D=[Decimal(0),Decimal(0)]
E=[Decimal(0),Decimal(0)]


A[0]=Decimal(random.random() )
A[1]=Decimal(random.random())

B[0]=Decimal(random.random())
B[1]=Decimal(random.random())

C[0]=Decimal(random.random())
C[1]=Decimal(random.random())

D[0]=Decimal(random.random())
D[1]=Decimal(random.random())

E[0]=Decimal(random.random())
E[1]=Decimal(random.random())
X=[Decimal(0),Decimal(0)]
Y=[Decimal(0),Decimal(0)]
Z=[Decimal(0),Decimal(0)]
W=[Decimal(0),Decimal(0)]
T=[Decimal(0),Decimal(0)]

#defining some useful functions--------------------------------------------
def v(a,b):
    result= [b[0]-a[0], b[1]-a[1]]
    return result 
def crs(a, b):
    result = [-Decimal(0.5)*((Decimal(a[0]*b[1])-Decimal(a[1]*b[0])))]
    return result
def dis(a,b):
    result =[Decimal(math.sqrt((a[0]-b[0])**2+(a[1]-b[1])**2))]
    return result 


 

for i in range (2,n+1):
    AB= dis(A,B)[0]
    BC= dis(B,C)[0]
    CD= dis(C,D)[0]
    DE= dis(D,E)[0]
    EA= dis(E,A)[0]



    #Here to calculate A_n--------------------------------------------
    x=   CD*crs(v(D,C),v(D,E))[0]
    y=  -CD*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(C,B),v(C,D))[0]
    z=  -CD*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(D,C),v(D,E))[0]
    t=   CD*crs(v(C,B),v(C,D))[0]
    X[0]=(x *B[0]+y*C[0]+z*D[0]+t*E[0])/(x+y+z+t)
    X[1]=(x *B[1]+y*C[1]+z*D[1]+t*E[1])/(x+y+z+t)



    #Here to calculate B_n--------------------------------------------
    x=   DE*crs(v(E,D),v(E,A))[0]
    y=  -DE*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(D,C),v(D,E))[0]
    z=  -DE*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(E,D),v(E,A))[0]
    t=   DE*crs(v(D,C),v(D,E))[0]
    Y[0]=(x *C[0]+y*D[0]+z*E[0]+t*A[0])/(x+y+z+t)
    Y[1]=(x *C[1]+y*D[1]+z*E[1]+t*A[1])/(x+y+z+t)



    #Here to calculate C_n--------------------------------------------
    x=   EA*crs(v(A,E),v(A,B))[0]
    y=  -EA*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(E,D),v(E,A))[0]
    z=  -EA*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(A,E),v(A,B))[0]
    t=   EA*crs(v(E,D),v(E,A))[0]
    Z[0]=(x *D[0]+y*E[0]+z*A[0]+t*B[0])/(x+y+z+t)
    Z[1]=(x *D[1]+y*E[1]+z*A[1]+t*B[1])/(x+y+z+t)



    #Here to calculate D_n--------------------------------------------
    x=   AB*crs(v(B,A),v(B,C))[0]
    y=  -AB*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(A,E),v(A,B))[0]
    z=  -AB*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(B,A),v(B,C))[0]
    t=   AB*crs(v(A,E),v(A,B))[0]
    W[0]=(x *E[0]+y*A[0]+z*B[0]+t*C[0])/(x+y+z+t)
    W[1]=(x *E[1]+y*A[1]+z*B[1]+t*C[1])/(x+y+z+t)



    #Here to calculate E_n--------------------------------------------
    x=   BC*crs(v(C,B),v(C,D))[0]
    y=  -BC*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(B,A),v(B,C))[0]
    z=  -BC*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(C,B),v(C,D))[0]
    t=   BC*crs(v(B,A),v(B,C))[0]
    T[0]=(x *A[0]+y*B[0]+z*C[0]+t*D[0])/(x+y+z+t)
    T[1]=(x *A[1]+y*B[1]+z*C[1]+t*D[1])/(x+y+z+t)
 


    A=X
    B=Y
    C=Z
    D=W
    E=T
    print(f"A_{i}= {A}")
    print(f"B_{i}= {B}")
    print(f"C_{i}= {C}")
    print(f"D_{i}= {D}")
    print(f"E_{i}= {E}")
    print("\n")
added 2532 characters in body
Source Link
pie
pie
  • 541
  • 4
  • 19

This is a python code than can calculate $A_n, B_n , C_n ,D_n ,E_n$

import math 
# enter your coordinates here
A=[0,0]
B=[1,1]
C=[3,5]
D=[2,7]
E=[2,6]

X=[0,0]
Y=[0,0]
Z=[0,0]
W=[0,0]
T=[0,0]

def v(a,b):
    result= [b[0]-a[0], b[1]-a[1]]

    return result 


def crs(a, b):
    result = [-0.5*((a[0]*b[1])-(a[1]*b[0]))]

    return result


def dis(a,b):
    result =[math.sqrt((a[0]-b[0])**2+(a[1]-b[1])**2)]
    return result 


for i in range (2,100+1):
    AB= dis(A,B)[0]
    BC= dis(B,C)[0]
    CD= dis(C,D)[0]
    DE= dis(D,E)[0]
    EA= dis(E,A)[0]



    #Here to calculate A_n
    x=   CD*crs(v(D,C),v(D,E))[0]
    y=  -CD*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(C,B),v(C,D))[0]
    z=  -CD*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(D,C),v(D,E))[0]
    t=   CD*crs(v(C,B),v(C,D))[0]
    X[0]=(x *B[0]+y*C[0]+z*D[0]+t*E[0])/(x+y+z+t)
    X[1]=(x *B[1]+y*C[1]+z*D[1]+t*E[1])/(x+y+z+t)



    #Here to calculate B_n
    x=   DE*crs(v(E,D),v(E,A))[0]
    y=  -DE*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(D,C),v(D,E))[0]
    z=  -DE*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(E,D),v(E,A))[0]
    t=   DE*crs(v(D,C),v(D,E))[0]
    Y[0]=(x *C[0]+y*D[0]+z*E[0]+t*A[0])/(x+y+z+t)
    Y[1]=(x *C[1]+y*D[1]+z*E[1]+t*A[1])/(x+y+z+t)



    #Here to calculate C_n
    x=   EA*crs(v(A,E),v(A,B))[0]
    y=  -EA*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(E,D),v(E,A))[0]
    z=  -EA*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(A,E),v(A,B))[0]
    t=   EA*crs(v(E,D),v(E,A))[0]
    Z[0]=(x *D[0]+y*E[0]+z*A[0]+t*B[0])/(x+y+z+t)
    Z[1]=(x *D[1]+y*E[1]+z*A[1]+t*B[1])/(x+y+z+t)



    #Here to calculate D_n
    x=   AB*crs(v(B,A),v(B,C))[0]
    y=  -AB*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(A,E),v(A,B))[0]
    z=  -AB*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(B,A),v(B,C))[0]
    t=   AB*crs(v(A,E),v(A,B))[0]
    W[0]=(x *E[0]+y*A[0]+z*B[0]+t*C[0])/(x+y+z+t)
    W[1]=(x *E[1]+y*A[1]+z*B[1]+t*C[1])/(x+y+z+t)



    #Here to calculate E_n
    x=   BC*crs(v(C,B),v(C,D))[0]
    y=  -BC*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(B,A),v(B,C))[0]
    z=  -BC*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(C,B),v(C,D))[0]
    t=   BC*crs(v(B,A),v(B,C))[0]
    T[0]=(x *A[0]+y*B[0]+z*C[0]+t*D[0])/(x+y+z+t)
    T[1]=(x *A[1]+y*B[1]+z*C[1]+t*D[1])/(x+y+z+t)
    A=X
    B=Y
    C=Z
    D=W
    E=T

    
    print(f"A_{i}= {A}")
    print(f"B_{i}= {B}")
    print(f"C_{i}= {C}")
    print(f"D_{i}= {D}")
    print(f"E_{i}= {E}")

This is a python code than can calculate $A_n, B_n , C_n ,D_n ,E_n$

import math 
# enter your coordinates here
A=[0,0]
B=[1,1]
C=[3,5]
D=[2,7]
E=[2,6]

X=[0,0]
Y=[0,0]
Z=[0,0]
W=[0,0]
T=[0,0]

def v(a,b):
    result= [b[0]-a[0], b[1]-a[1]]

    return result 


def crs(a, b):
    result = [-0.5*((a[0]*b[1])-(a[1]*b[0]))]

    return result


def dis(a,b):
    result =[math.sqrt((a[0]-b[0])**2+(a[1]-b[1])**2)]
    return result 


for i in range (2,100+1):
    AB= dis(A,B)[0]
    BC= dis(B,C)[0]
    CD= dis(C,D)[0]
    DE= dis(D,E)[0]
    EA= dis(E,A)[0]



    #Here to calculate A_n
    x=   CD*crs(v(D,C),v(D,E))[0]
    y=  -CD*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(C,B),v(C,D))[0]
    z=  -CD*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(D,C),v(D,E))[0]
    t=   CD*crs(v(C,B),v(C,D))[0]
    X[0]=(x *B[0]+y*C[0]+z*D[0]+t*E[0])/(x+y+z+t)
    X[1]=(x *B[1]+y*C[1]+z*D[1]+t*E[1])/(x+y+z+t)



    #Here to calculate B_n
    x=   DE*crs(v(E,D),v(E,A))[0]
    y=  -DE*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(D,C),v(D,E))[0]
    z=  -DE*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(E,D),v(E,A))[0]
    t=   DE*crs(v(D,C),v(D,E))[0]
    Y[0]=(x *C[0]+y*D[0]+z*E[0]+t*A[0])/(x+y+z+t)
    Y[1]=(x *C[1]+y*D[1]+z*E[1]+t*A[1])/(x+y+z+t)



    #Here to calculate C_n
    x=   EA*crs(v(A,E),v(A,B))[0]
    y=  -EA*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(E,D),v(E,A))[0]
    z=  -EA*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(A,E),v(A,B))[0]
    t=   EA*crs(v(E,D),v(E,A))[0]
    Z[0]=(x *D[0]+y*E[0]+z*A[0]+t*B[0])/(x+y+z+t)
    Z[1]=(x *D[1]+y*E[1]+z*A[1]+t*B[1])/(x+y+z+t)



    #Here to calculate D_n
    x=   AB*crs(v(B,A),v(B,C))[0]
    y=  -AB*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(A,E),v(A,B))[0]
    z=  -AB*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(B,A),v(B,C))[0]
    t=   AB*crs(v(A,E),v(A,B))[0]
    W[0]=(x *E[0]+y*A[0]+z*B[0]+t*C[0])/(x+y+z+t)
    W[1]=(x *E[1]+y*A[1]+z*B[1]+t*C[1])/(x+y+z+t)



    #Here to calculate E_n
    x=   BC*crs(v(C,B),v(C,D))[0]
    y=  -BC*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(B,A),v(B,C))[0]
    z=  -BC*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(C,B),v(C,D))[0]
    t=   BC*crs(v(B,A),v(B,C))[0]
    T[0]=(x *A[0]+y*B[0]+z*C[0]+t*D[0])/(x+y+z+t)
    T[1]=(x *A[1]+y*B[1]+z*C[1]+t*D[1])/(x+y+z+t)
    A=X
    B=Y
    C=Z
    D=W
    E=T

    
    print(f"A_{i}= {A}")
    print(f"B_{i}= {B}")
    print(f"C_{i}= {C}")
    print(f"D_{i}= {D}")
    print(f"E_{i}= {E}")
added 192 characters in body
Source Link
pie
pie
  • 541
  • 4
  • 19
added 87 characters in body
Source Link
pie
pie
  • 541
  • 4
  • 19
added 4 characters in body
Source Link
Michael Hardy
Michael Hardy
  • 1
  • 12
  • 85
  • 126
edited title
Source Link
Michael Hardy
Michael Hardy
  • 1
  • 12
  • 85
  • 126
deleted 12 characters in body
Source Link
pie
pie
  • 541
  • 4
  • 19
Notice added Draw attention by pie
Bounty Started worth 100 reputation by pie
added 110 characters in body
Source Link
pie
pie
  • 541
  • 4
  • 19
added 6 characters in body
Source Link
pie
pie
  • 541
  • 4
  • 19
added 115 characters in body
Source Link
pie
pie
  • 541
  • 4
  • 19
added 185 characters in body; edited tags
Source Link
pie
pie
  • 541
  • 4
  • 19
edited body
Source Link
pie
pie
  • 541
  • 4
  • 19
formatting
Source Link
YCor
YCor
  • 63.9k
  • 5
  • 187
  • 285
Source Link
pie
pie
  • 541
  • 4
  • 19