CERCLES-02
kitcircle := S = (1/4)*a*b*c/R, e = sqrt(-a^2*c^2+c^4-b^2*c^2-a^2*b^2+a^4+b^4)/sqrt(a^2*b^2+a^2*c^2+b^2*c^2), {cos(omega) = (1/2)*(a^2+b^2+c^2)/sqrt(a^2*b^2+a^2*c^2+b^2*c^2), sin(omega) = (1/2)*a*b*c/(R*sqrt(a^2*b^2+a^2*c^2+b^2*c^2))}, r = (1/2)*c*b*a/((a+b+c)*R), s = (1/2)*a+(1/2)*b+(1/2)*c;
WW1:= sqrt(a^2*b^2+a^2*c^2+b^2*c^2);
WW2:= sqrt(-a^2*c^2+c^4-b^2*c^2-a^2*b^2+a^4+b^4);
WW3:= sqrt(a^6-a^4*b^2-a^4*c^2-a^2*b^4+3*a^2*b^2*c^2-a^2*c^4+b^6-b^4*c^2-b^2*c^4+c^6);
WW4:= sqrt(b^3-b^2*c-b*c^2+c^3-a*b^2+3*a*b*c-a*c^2-a^2*b-a^2*c+a^3);
<Text-field style="Heading 1" layout="Heading 1"><Font encoding="UTF-8">Equation cercle (d\303\251terminant \303\240 la Kimberling)</Font></Text-field>
circ:= proc (x, y) options operator, arrow; [y^2+x^2, x, y, 1] end proc;
Le principe du d\303\251terminant
Matrix([circ(xi,eta), seq(circ(xi[j],eta[j]), j=1..3)]); #latexx(0), latexz(%);
matri:= Matrix([za,zb,zc]); mafac:= Diag(x+y+z,p1+q1+r1,p2+q2+r2,p3+q3+r3);
magic:= Matrix(map( circ@op@bary2proj, [px,pp1,pp2,pp3]));
SubMatrix(magic,1..4,2..4); FActor(mafac.%. (1/matri));
matri4:= DiagonalMatrix([1, matri]);
tmp:= FActor(mafac.magic. (1/matri4));
Row(tmp,1);
tmp[1,1]*(x+y+z): collect(%, px, distributed);
finafac:= <<-1, +ya^2+xa^2, yb^2+xb^2, yc^2+xc^2> | <<0|0|0>, mun>>;
FActor(tmp.%): map(factor@simplify, collect(%, px, distributed), rule123);
FActor(mafac.magic. (1/matri4).finafac): (FActor@simplify)(%, rule123):
subs(seq(seq( cat(k,j)=k[j], j=[1,2,3]), k=[p,q,r]), %);
# latexx(mafac), latexy(matri4), latexy(finafac), latexz(%);
<Text-field style="Heading 1" layout="Heading 1">Equation cercle par centre et rayon</Text-field>
basique : pythagore
-pytha(pp,px)+rho2:
tmp:= collect(%*(x+y+z)^2, rho2, factor);
-k*tmp+rho2*(x+y+z)^2+eqcircum(px)-(x+y+z)*ps(pu,px): {coeffs(expand(%), px)}:
eli:= (factor@eliminate)(%, {k,u,v, w});
pp2uu:= unapply(subs(eli[1], pu), p,q,r)@OP;
eq_dou:= eqcircum(px)+rho2*(x+y+z)^2-ps(pu,px)*(x+y+z);
test ok
factor(subs(zipq(pu, pp2uu(pp)), eq_dou)-tmp);;
#latexx(0),latexy(eq_dou), latexz(pp2uu(pp));
wolf:= (l*alpha+m*beta+n*gamma)*(a*alpha+b*beta+c*gamma)+(a*beta*gamma+b*gamma*alpha+c*alpha*beta):subs(alpha=x/a, beta=y/b, gamma=z/c, %):
eq_wolf:= xcollect(%*a*b*c, [x+y+z], factor);
R\303\250gle de calcul
subs(zipq(px,pa), eq_wolf)/b/c;
(eq_dou-eq_wolf)/(x+y+z): collect(factor(%), [x,y,z]):
solve({coeffs}(%, px),{l,m,n}): subs(%, [l,m,n]);
<Text-field style="Heading 1" layout="Heading 1">condilou, elimination des pp2uu</Text-field>
evalms(pp2uu(pp)-pu): eli:= eliminate(%, {p,q}):
tmp:= select(has,op(eli[2]),{v});
(factor@subs)(zipq(pu,pp2uu(pp)), op(1,tmp));
(factor@subs)(zipq(pu,pp2uu(pp)), op(2,tmp));
collect(op(2,tmp), pu, factor, distributed):
condilou:= xcollect(%,[rot3(a^2+b^2-c^2)]);
evalms(pp2uu(pp)-k*pp2uu(px)): eliq:= [eliminate](%, {k,p,q});;
(reduce@subs)(eliq[1][1], pp);
(reduce@subs)(eliq[2][1], pp): collect(%, px, distributed);
lequi:= unapply(%,x,y,z)@OP:
<Text-field style="Heading 1" layout="Heading 1"><Font encoding="UTF-8">Quelles sont les coniques qui s'\303\251crivent ainsi</Font></Text-field>
eq_dou-k*evalm(px &* mm &* px); {coeffs}(expand(%), px) union {condilou};
eli:= eliminate(%, {k,u,v,w,rho2}):
collect(eli[2], [m11,m22,m33]);
condicir:= subs(AAA=%, BBB= eli[1], proc(MM) zipq(mm,MM):
subs(%, AAA), subs(%,BBB) end):
(eq2mm@eqcircum)(px); tmpa,tmpb:= condicir(%): tmpa; subs(apbpc, factor(tmpb));
subs(%, pu), subs(%,rho2); (simplify@subs)(%%, eq_dou);
eq2mm(eqincircle); tmpa, tmpb:= condicir(%): factor(tmpa);
factor(tmpb): uu_in:= subs(%, pu): %, (factor@subs)(%%, isolate(defR2, b+a-c), rho2);
bary2norm(cent)+(bary2norm(px)-bary2norm(cent))*rad2/(rad2+eqn2):
tmq:= (reduce@factor@evalmm)(%):;
collect(tmq[1]/rotp(1), px, factor, distributed);
invcircum:= unapply([rot3](%), x,y,z)@OP:
# simplify(%%, a2toAA): collect(%, px, factor, distributed);
subs(ency_, tmq); funinv:= unapply(reduce(%),x,y,z)@op;
<Text-field style="Heading 1" layout="Heading 1"><Font encoding="UTF-8">Quels sont les points o\303\271 arrive un pp2uu ?</Font></Text-field>
Une coordonn\303\251e \303\240 la fois
evalms(pp2uu(pp)-k*pu); eli:= eliminate(%, {k,p}): nops([%]);
collect(op(eli[2]), q); delta:= factor(discrim(%, q)/r^2); indets(%);
conilou:= select(has,%%, a^4);
inconic, perspecteur 76, centre 141
coni_in(pp)-subs(zipq(pu,px),conilou): {coeffs}(%, px);
solve(%, {p,q,r}): subs(%, pp); ency(%);
(reduce@barymul)(%%, complem(%%)); ency(%);
Les contacts de l'ellipse sont les pp2uu des sommets
pp2uu(pa), pp2uu(pb), pp2uu(pc);
(numer@pp2uu)(px)[1]; discrim(%, y);
Les points \303\240 l'infini donneraient.... le centre de gravit\303\251
(reduce@pp2uu)(pp): (reduce@factor@subs)(zipq(pp, prm_inf(pdr)),%);
Il faut conilou n\303\251gatif pour que q soit r\303\251el
solq:= factor([solve](op(eli[2]), {q})):
subs(apbpc, conilou=-con^2, solq):
solqq:= simplify(%) assuming a>0,b>0,c>0,R>0, con>0, -b^2*v+u*b^2+c^2*w-u*c^2 >0:
Test de conjugaison
factor(subs(solqq[1],q/r)+subs(solqq[2],q/r)): indets(%);
defR2;
(factor@subs)(eli[1], solqq[1], pp):
(factor@subs)(con^2=-conilou, collect(%, con)): tmp:= (expand@reduce)(%):
(reduce@factor@subs)(con^2=-conilou, defR2, tmp):
tmp1:= collect(%, con, factor):
collect(add(k, k=tmp1), con, factor):
tmp2:= expand(evalmm(subs(con=-con, %)*tmp1)):
tmp3:= (reduce@factor@subs)(con^2=-conilou, defR2, tmp2):
Et on a enfin une \303\251quation sym\303\251trique
tmp4:= collect(tmp3, [con,R], U-> collect(U, pu, factor, distributed)); factor(rot(tmp4[1])/tmp4[2]);
subs(con=0, tmp4); part1:= Vector(map(U-> a*b*c*map(V->V/a/b/c,U),%));
part2:= (Vector@map2)(select,has,tmp4,R);
<Text-field style="Heading 2" layout="Heading 2"><Font encoding="UTF-8">Le graphe des points dont un multiple v\303\251rifie condilou</Font></Text-field>
Pour un point u:v:w, il n'est pas toujours possible de trouver un k qui aille bien.
condi1:= subs(u=k*u,v=k*v,w=k*w, condilou): factor(discrim(%, k));
subs(zipq(pu, pX(8)), ency_, condi1); solve(%);
(factor@subs)(ency_, cetriangle, bary2proj(pp2uu(pp))):
funlou:= unapply(subsop(3=NULL, %),p,q,r)@op;
(expand@subs)(zipq(pu, projx), ency_, conilou):evalf(%/10000);
pl1:= implicitplot(%, X=-0.4..1, Y=-1..0, grid=[50,50], thickness=3):
pl2:= pointplot([seq](funlou(xyz[j]), j=1..jmax)):
pl20:= pointplot([seq](`if`(ff[j]=1,funlou(xyz[j]),NULL), j=1..jmax)):
[color=blue]: pl0:= dralinpts(pa,pb,%),dralinpts(pb,pc,%),dralinpts(pc,pa,%):
pl3:= drawna(pX(141),"c",2,[color=blue]):
Magnifique accord des deux graphes
display(pl0, pl1, pl3, pl20, view=[-1.5..1.5,-1.5..0.5], scaling=constrained);
ckoi:= (reduce@factor@subs)(eli[1][1], pp): map(length, %);
ckoi2:= simplify(ckoi, {condilou}):map(length, %);
<Text-field style="Heading 1" layout="Heading 1">Cercles en tout genre (il faut Digits = 30)</Text-field>
Digits:=30:
Le kit circle
# valr := r = (1/2)*a*b*c/((a+b+c)*R)
# kitcircle:= isolate(defR, S), vale, valom, valr, s=(a+b+c)/2;
kitcircle := S = (1/4)*a*b*c/R, e = sqrt(-a^2*c^2+c^4-b^2*c^2-a^2*b^2+a^4+b^4)/sqrt(a^2*b^2+a^2*c^2+b^2*c^2), {cos(omega) = (1/2)*(a^2+b^2+c^2)/sqrt(a^2*b^2+a^2*c^2+b^2*c^2), sin(omega) = (1/2)*a*b*c/(R*sqrt(a^2*b^2+a^2*c^2+b^2*c^2))}, s = (1/2)*a+(1/2)*b+(1/2)*c, r = (1/2)*a*b*c/((a+b+c)*R);
WW1:= sqrt(a^2*b^2+a^2*c^2+b^2*c^2);
WW2:= sqrt(-a^2*c^2+c^4-b^2*c^2-a^2*b^2+a^4+b^4);
WW3:= sqrt(a^6-a^4*b^2-a^4*c^2-a^2*b^4+3*a^2*b^2*c^2-a^2*c^4+b^6-b^4*c^2-b^2*c^4+c^6);
WW4:= sqrt(b^3-b^2*c-b*c^2+c^3-a*b^2+3*a*b*c-a*c^2-a^2*b-a^2*c+a^3);
pytha(pp,px): factor(%):
collect(%, px, U->collect(U, pp, factor, distributed), distributed):
subs(a2toAA,%);
map(1/id, defR2)*a^2*b^2*c^2: ruleR:= -(expand@(rhs=lhs))(%);
Antipodes sur le circumcircle
_P:= pp; _O1:=pX(3);
_PP:= collect(reflection(_O1,pp), pp, factor);
_P1:= prm_cir(pdr); _PP1:= (elimifacu@reflection)(_O1,%): collect(%, pdr): Vector(%);;;
<Text-field style="Heading 1" layout="Heading 1">Circumcircle </Text-field>
num_cent:=3; cent:= pX(%): rad2:= (R)^2;
(factor@pp2uu)(cent): ccir_uu:= (Vector@factor@subs)(apbpc,%); ici_uu:=%: ency(%);
subs(rho2=rad2, zipq(Vector(pu), ici_uu), eq_dou):
(factor@subs)(defR2, %);
eqn0:= sort(collect(%, px, factor, distributed), [x,y,z]);
circlefunction:= subs(y=0,z=0,x=1,eqn0)/b/c;
fac:=1:
ici_eqn:= Sum(coeff(eqn0,x,2)*x^2,j)+fac*Sum(coeff(coeff(eqn0,y),z)/fac*y*z,j);
(factor@mm2persp@eq2mm)(eqn0): ici_persp:= elimifacu(%); ency(%);
rad2-eqn0/(x+y+z)^2;
tmp:= bary2norm(cent)+(bary2norm(px)-bary2norm(cent))*rad2/(rad2-eqn0/(x+y+z)^2):
tmq:= (reduce@factor@evalmm)(%): (Vector@factor@subs)(defR2, %):
collect(-%/rotp(a^2), px, normal@expand, distributed);
les fonctions funon, funinv, funsym
(reduce@factor@evalmm@subs)(ency_, tmp): funinv:= unapply(%,x,y,z)@op:
funon:= unapply(subs(ency_, eqn0), x,y,z)@op:
(reduce@subs)(ency_, reflection(pX(3),px)): funsym:= unapply(%,x,y,z)@op:
Bien r\303\251gler le seuil... ou bien passer \303\240 20 chiffres
ici_on:= [seq](`if`((abs@funon)(xyz[j])<Float(1,-6),j,NULL),j=1..jmax): nops(%);
Points \303\240 l'infini sans isogon nomm\303\251
seq(`if`(ff[j]=1 and gg[j]=0,j,NULL), j=1..jmax); nops([%]);
12,19,36,58,101; seq(ency( (bary2norm)(pX(j))-bary2norm(pX(2))), j=%);
Les antipodaux
qqr:= table(): for j in ici_on do tmp:= ency(funsym(xyz[j])):
if tmp <>`?` then qqr[j]:= tmp; fi; od: j:='j':
lesk:= sort(map(op,[indices](qqr))); nops(%);
bad_points=seq(`if`(qqr[qqr[j]]=j,NULL,j), j=lesk);
Il faut envoyer cela ***si besoin*** dans un r\303\251pertoire lisible et navigable
if false then
try close(fd); catch : end try;
fd := open("/home/douillet/public_html/etc/alt_data.csv", WRITE):
for j in lesk do
fprintf(fd, """%d"";""%d""\134n", j, qqr[j]);
od: close(fd); j:='j':
fi:
<Text-field style="Heading 1" layout="Heading 1">Incircle + antipodie</Text-field>
num_cent:=1; cent:= pX(%): rad2:= (subs(kitcircle, r))^2;
in_rad:= map(sqrt, rad2) assuming a>0,b>0,c>0,R>0; ici_rad:= %:
(factor@pp2uu)(cent): in_uu:= (Vector@factor@subs)(defR2,%); ici_uu:=%: ency(%);
subs(rho2=rad2, valR22, zipq(Vector(pu), ici_uu), eq_dou):
eqn0:= sort(collect(%, px, factor, distributed), [x,y,z]);
circlefunction:= subs(y=0,z=0,x=1,eqn0)/b/c;
<Text-field style="Heading 2" layout="Heading 2">antipodie</Text-field>
_O1:= pX(3); _O2:= cent;
(R*bary2norm(cent)- ici_rad*bary2norm(pX(3)))/(R-ici_rad):
(reduce@FActor@evalmm)(%): _V:= (elimifacu@FActor@subs)(defR2, %); ency(%);
(R*bary2norm(cent) + ici_rad*bary2norm(pX(3)))/(R+ici_rad):
(reduce@FActor@evalmm)(%): _U:= (elimifacu@FActor@subs)(defR2, %);ency(%);
(reduce@factor@wedge)(wedge(_P,_U),wedge(_PP,_V)):
collect(%, pp, factor): _Q:= Vector(xcollect(%, [rot3](-a+b+c)));
(elimifacu@factor@wedge)(wedge(_PP,_U),wedge(_P,_V)):
collect(%, pp, factor): _QQ:= Vector(xcollect(-%, [rot3](-a+b+c)));
(reduce@factor)(bary2norm(_Q)+bary2norm(_QQ))=cent;
fac:=a^2: subs(zipq(pp, prm_cir(pdr)), _Q):
%[1]: map(U-> U/fac, op(1,%))*fac*op(2,%):
_Qprm:= Vector([rot3](%));
fac:=a^2: subs(zipq(pp, prm_cir(pdr)), _QQ):
%[1]: map(U-> U/fac, op(1,%))*fac*op(2,%):
_QQprm:= Vector([rot3](%));
unapply(eqn0, x,y,z)@OP: map(factor@%, [_Q,_QQ,_Qprm,_QQprm]):
subs(eqcircum(pp)=0, %);;
facxx, facyz:=-1/4, 1/2:
ici_eqn:= facxx*Sum(coeff(eqn0,x,2)/facxx*x^2,j)+
facyz*Sum(coeff(coeff(eqn0,y),z)/facyz*y*z,j);
(factor@mm2persp@eq2mm)(eqn0): ici_persp:= elimifacu(%); ency(%);
tmp_inv:= bary2norm(cent)+(bary2norm(px)-bary2norm(cent))*rad2/(rad2-eqn0/(x+y+z)^2):
tmq:= (reduce@factor@evalmm)(%): (Vector@factor@subs)(defR2, %):
collect(-%/rotp(a^2), px, normal@expand, distributed);
les fonctions funon, funinv, funsym
(reduce@factor@evalmm@subs)(ency_, tmp_inv): funinv:= unapply(%,x,y,z)@op:
funon:= unapply(subs(ency_, eqn0), x,y,z)@op:
(reduce@subs)(ency_, reflection(cent,px)): funsym:= unapply(%,x,y,z)@op:
Bien r\303\251gler le seuil... ou bien passer \303\240 20 chiffres
ici_on:= [seq](`if`((abs@funon)(xyz[j])<Float(1,-6),j,NULL),j=1..jmax): nops(%);
Les inverses-in-circle
qqr:= table(): for j to jmax do if ff[j]=1 then next fi;
tmp:= ency(funinv(xyz[j])):
if tmp <>`?` then qqr[j]:= tmp; fi; od: # j:='j':
ici_inv:= sort(map(op,[indices](qqr))); nops(%);
bad_points=seq(`if`(qqr[qqr[j]]=j,NULL,j), j=ici_inv);
On doit retrouver le nombre de points sur le cercle
[seq](`if`(qqr[j]=j,j,NULL),j=ici_inv): nops(%);
Les antipodaux
qqr:= table(): for j in ici_on do tmp:= ency(funsym(xyz[j])):
if tmp <>`?` then qqr[j]:= tmp; fi; od: j:='j':
lesk:= sort(map(op,[indices](qqr))); nops(%);
bad_points=seq(`if`(qqr[qqr[j]]=j,NULL,j), j=lesk);
Il faut envoyer cela ***si besoin*** dans un r\303\251pertoire lisible et navigable
if false then
try close(fd); catch : end try;
fd := open("/home/douillet/public_html/etc/alt_data.csv", WRITE):
for j in lesk do
fprintf(fd, """%d"";""%d""\134n", j, qqr[j]);
od: close(fd); j:='j':
fi:
<Text-field style="Heading 1" layout="Heading 1">Nine points (new)</Text-field>
num_cent:=5; cent:= pX(%): rad2:= (R/2)^2;
(factor@pp2uu)(cent): in_uu:= (Vector@factor@subs)(defR2,%); ici_uu:=%: ency(%);
Essai pour plubo
# subs(apbpc, in_uu); (factor)(add(k,k=in_uu)); in_uu-%*Vector([1,1,1]): FActor(%);
subs(rho2=rad2, valR22, zipq(Vector(pu), ici_uu), eq_dou):
eqn0:= sort(collect(%, px, factor, distributed), [x,y,z]);
circlefunction:= subs(y=0,z=0,x=1,eqn0)/b/c;
facxx, facyz:=-1/4, 1/2: j:='j':
ici_eqn:= facxx*Sum( simplify(coeff(eqn0,x,2)/facxx)*x^2,j)+
facyz*Sum(coeff(coeff(eqn0,y),z)/facyz*y*z,j);
(factor@mm2persp@eq2mm)(eqn0): ici_persp:= elimifacu(%); ency(%);
tmp_inv:= bary2norm(cent)+(bary2norm(px)-bary2norm(cent))*rad2/(rad2-eqn0/(x+y+z)^2):
#tmq:= (reduce@factor@evalmm)(%): (Vector@factor@subs)(defR2, %):
#collect(-%/rotp(a^2), px, normal@expand, distributed);
les fonctions funon, funinv, funsym
(reduce@factor@evalmm@subs)(ency_, tmp_inv): funinv:= unapply(%,x,y,z)@op:
funon:= unapply(subs(ency_, eqn0), x,y,z)@op:
(reduce@subs)(ency_, reflection(cent,px)): funsym:= unapply(%,x,y,z)@op:
Bien r\303\251gler le seuil... ou bien passer \303\240 20 chiffres
ici_on:= [seq](`if`((abs@funon)(xyz[j])<Float(1,-6),j,NULL),j=1..jmax): nops(%);
Les inverses-in-circle
qqr:= table(): for j to jmax do if ff[j]=1 then next fi;
tmp:= ency(funinv(xyz[j])):
if tmp <>`?` then qqr[j]:= tmp; fi; od: # j:='j':
ici_inv:= sort(map(op,[indices](qqr))); nops(%);
bad_points=seq(`if`(qqr[qqr[j]]=j,NULL,j), j=ici_inv);
On doit retrouver le nombre de points sur le cercle
[seq](`if`(qqr[j]=j,j,NULL),j=ici_inv): nops(%);
Les antipodaux
qqr:= table(): for j in ici_on do tmp:= ency(funsym(xyz[j])):
if tmp <>`?` then qqr[j]:= tmp; fi; od: j:='j':
lesk:= sort(map(op,[indices](qqr))); nops(%);
bad_points=seq(`if`(qqr[qqr[j]]=j,NULL,j), j=lesk);
Il faut envoyer cela ***si besoin*** dans un r\303\251pertoire lisible et navigable
if false then
try close(fd); catch : end try;
fd := open("/home/douillet/public_html/etc/alt_data.csv", WRITE):
for j in lesk do
fprintf(fd, """%d"";""%d""\134n", j, qqr[j]);
od: close(fd); j:='j':
fi:
<Text-field style="Heading 1" layout="Heading 1">Bevan : circumcircle of excentral triangle (new)</Text-field>
num_cent:=40; cent:= pX(%): rad2:= (2*R)^2;
(factor@pp2uu)(cent): bev_uu:= (Vector@factor@subs)(defR2,%); ici_uu:=%: ency(%);
map(normal@simplify, bev_uu, {ruleR}):
bev_uu:= (EXpand@subs)(isolate(ruleR, a^4), %);
subs(rho2=rad2, valR22, zipq(Vector(pu), ici_uu), eq_dou):
eqn0:= sort(collect(%, px, factor, distributed), [x,y,z]);
circlefunction:= subs(y=0,z=0,x=1,eqn0)/b/c;
facxx, facyz:=1, a+b+c: j:='j':
ici_eqn:= facxx*Sum( simplify(coeff(eqn0,x,2)/facxx)*x^2,j)+
facyz*Sum(coeff(coeff(eqn0,y),z)/facyz*y*z,j);
(factor@mm2persp@eq2mm)(eqn0): ici_persp:= elimifacu(%); ency(%);
tmp_inv:= bary2norm(cent)+(bary2norm(px)-bary2norm(cent))*rad2/(rad2-eqn0/(x+y+z)^2):
#tmq:= (reduce@factor@evalmm)(%): (Vector@factor@subs)(defR2, %):
#collect(-%/rotp(a^2), px, normal@expand, distributed);
les fonctions funon, funinv, funsym
(reduce@factor@evalmm@subs)(ency_, tmp_inv): funinv:= unapply(%,x,y,z)@op:
funon:= unapply(subs(ency_, eqn0), x,y,z)@op:
(reduce@subs)(ency_, reflection(cent,px)): funsym:= unapply(%,x,y,z)@op:
Bien r\303\251gler le seuil... ou bien passer \303\240 20 chiffres
Digits:=20:
ici_on:= [seq](`if`((abs@funon)(xyz[j])<Float(1,-6),j,NULL),j=1..jmax): nops(%);
Les inverses-in-circle
qqr:= table(): for j to jmax do if ff[j]=1 then next fi;
tmp:= ency(funinv(xyz[j])):
if tmp <>`?` then qqr[j]:= tmp; fi; od: # j:='j':
ici_inv:= sort(map(op,[indices](qqr))); nops(%);
bad_points=seq(`if`(qqr[qqr[j]]=j,NULL,j), j=ici_inv);
On doit retrouver le nombre de points sur le cercle
[seq](`if`(qqr[j]=j,j,NULL),j=ici_inv): nops(%);
Les antipodaux
qqr:= table(): for j in ici_on do tmp:= ency(funsym(xyz[j])):
if tmp <>`?` then qqr[j]:= tmp; fi; od: j:='j':
lesk:= sort(map(op,[indices](qqr))); nops(%);
bad_points=seq(`if`(qqr[qqr[j]]=j,NULL,j), j=lesk);
Digits:=10:
Il faut envoyer cela ***si besoin*** dans un r\303\251pertoire lisible et navigable
if false then
try close(fd); catch : end try;
fd := open("/home/douillet/public_html/etc/alt_data.csv", WRITE):
for j in lesk do
fprintf(fd, """%d"";""%d""\134n", j, qqr[j]);
od: close(fd); j:='j':
fi:
<Text-field style="Heading 1" layout="Heading 1">Brocard (new)</Text-field>
num_cent:=182; cent:= pX(%);
rad2:= subs(kitcircle, defR2, (e*R/cos(omega)/2)^2 );
(factor@pp2uu)(cent): broc_uu:= (Vector@factor@subs)(defR2,%); ici_uu:=%: ency(%);
broc_uu:= map(sort, subs(apbpc, broc_uu), [a,b,c]);
subs(rho2=rad2, valR22, zipq(Vector(pu), ici_uu), eq_dou):
eqn0:= sort(collect(%, px, factor, distributed), [x,y,z]);
circlefunction:= subs(y=0,z=0,x=1,eqn0)/b/c;
facxx, facyz:=1/(a^2+b^2+c^2) $2: j:='j':
A(facxx)*Sum( simplify(coeff(eqn0,x,2)/facxx)*x^2,j)+
A(facyz)*Sum(coeff(coeff(eqn0,y),z)/facyz*y*z,j):
ici_eqn:= sort(%, [x,y,z]);
(factor@mm2persp@eq2mm)(eqn0): ici_persp:= elimifacu(%); ency(%);
tmp_inv:= bary2norm(cent)+(bary2norm(px)-bary2norm(cent))*rad2/(rad2-eqn0/(x+y+z)^2):
#tmq:= (reduce@factor@evalmm)(%): (Vector@factor@subs)(defR2, %):
#collect(-%/rotp(a^2), px, normal@expand, distributed);
les fonctions funon, funinv, funsym
(reduce@factor@evalmm@subs)(ency_, tmp_inv): funinv:= unapply(%,x,y,z)@op:
funon:= unapply(subs(ency_, eqn0), x,y,z)@op:
(reduce@subs)(ency_, reflection(cent,px)): funsym:= unapply(%,x,y,z)@op:
Bien r\303\251gler le seuil... ou bien passer \303\240 20 chiffres
Digits:=20:
ici_on:= [seq](`if`((abs@funon)(xyz[j])<Float(1,-6),j,NULL),j=1..jmax); nops(%);
Les inverses-in-circle
qqr:= table(): for j to jmax do if ff[j]=1 then next fi;
tmp:= ency(funinv(xyz[j])):
if tmp <>`?` then qqr[j]:= tmp; fi; od: # j:='j':
ici_inv:= sort(map(op,[indices](qqr))); nops(%);
bad_points=seq(`if`(qqr[qqr[j]]=j,NULL,j), j=ici_inv);
On doit retrouver le nombre de points sur le cercle
[seq](`if`(qqr[j]=j,j,NULL),j=ici_inv): nops(%);
Les antipodaux
qqr:= table(): for j in ici_on do tmp:= ency(funsym(xyz[j])):
if tmp <>`?` then qqr[j]:= tmp; fi; od: j:='j':
lesk:= sort(map(op,[indices](qqr))); nops(%);
bad_points=seq(`if`(qqr[qqr[j]]=j,NULL,j), j=lesk);
Digits:=10:
Il faut envoyer cela ***si besoin*** dans un r\303\251pertoire lisible et navigable
if false then
try close(fd); catch : end try;
fd := open("/home/douillet/public_html/etc/alt_data.csv", WRITE):
for j in lesk do
fprintf(fd, """%d"";""%d""\134n", j, qqr[j]);
od: close(fd); j:='j':
fi:
<Text-field style="Heading 1" layout="Heading 1">Spieker +antipodie</Text-field>
j:='j': num_cent:=10; cent:= pX(%);
rad2:= subs(kitcircle, valR22, (r/2)^2 );
(factor@pp2uu)(cent): spie_uu:= (Vector@factor@subs)(defR2,%); ici_uu:=%: ency(%);
isolate(defR2, a+b-c):
spie_rad:= (sqrt@factor@subs)(%, rad2) assuming a>0,b>0,c>0,R>0;ici_rad:=%:
subs(rho2=rad2, valR22, zipq(Vector(pu), ici_uu), eq_dou):
eqn0:= sort(collect(%, px, factor, distributed), [x,y,z]);
circlefunction:= subs(y=0,z=0,x=1,eqn0)/b/c;
<Text-field style="Heading 2" layout="Heading 2">antipodie</Text-field>
_O1:= pX(3); _O2:= cent;
(R*bary2norm(cent)- ici_rad*bary2norm(pX(3)))/(R-ici_rad):
(reduce@FActor@evalmm)(%): _V:= (elimifacu@FActor@subs)(defR2, %); ency(%);
(R*bary2norm(cent) + ici_rad*bary2norm(pX(3)))/(R+ici_rad):
(reduce@FActor@evalmm)(%): _U:= (elimifacu@FActor@subs)(defR2, %);ency(%);
(reduce@factor@wedge)(wedge(_P,_U),wedge(_PP,_V)):
collect(%, pp, factor): _Q:= Vector(xcollect(%, [rot3](-a+b+c)));
(elimifacu@factor@wedge)(wedge(_PP,_U),wedge(_P,_V)):
collect(%, pp, factor): _QQ:= Vector(xcollect(-%, [rot3](-a+b+c)));
(reduce@factor)(bary2norm(_Q)+bary2norm(_QQ))=cent;
fac:=a^2: subs(zipq(pp, prm_cir(pdr)), _Q):
_Qprm:= Vector(%);
fac:=a^2: subs(zipq(pp, prm_cir(pdr)), _QQ):
_QQprm:= Vector(%);
unapply(eqn0, x,y,z)@OP: map(factor@%, [_Q,_QQ,_Qprm,_QQprm]):
subs(eqcircum(pp)=0, %);;
fac:= b+c-a: unapply(convert(_Q,list),p,q,r)@op: tokim(%,pp):
collect(%[1]/fac, pp, factor): xcollect(%, [a*b+2*b*c+a^2+a*c,p,a], factor);
fac:= 1: unapply(convert(_QQ,list),p,q,r)@op: tokim(%,pp):
collect(%[1]/fac, pp, factor): xcollect(%, [-a*b+2*b*c+a^2-a*c,p,a], factor);
facxx, facyz:=1/16, (a+b+c)/8: j:='j':
A(facxx)*Sum( simplify(coeff(eqn0,x,2)/facxx)*x^2,j)+
A(facyz)*Sum(simplify(coeff(coeff(eqn0,y),z)/facyz)*y*z,j):
ici_eqn:= sort(%, [x,y,z,a,b,c]);
(factor@mm2persp@eq2mm)(eqn0): ici_persp:= elimifacu(%); ency(%);
tmp_inv:= bary2norm(cent)+(bary2norm(px)-bary2norm(cent))*rad2/(rad2-eqn0/(x+y+z)^2):
#tmq:= (reduce@factor@evalmm)(%): (Vector@factor@subs)(defR2, %):
#collect(-%/rotp(a^2), px, normal@expand, distributed);
les fonctions funon, funinv, funsym
(reduce@factor@evalmm@subs)(ency_, tmp_inv): funinv:= unapply(%,x,y,z)@op:
funon:= unapply(subs(ency_, eqn0), x,y,z)@op:
(reduce@subs)(ency_, reflection(cent,px)): funsym:= unapply(%,x,y,z)@op:
Bien r\303\251gler le seuil... ou bien passer \303\240 20 chiffres
Digits:=20:
ici_on:= [seq](`if`((abs@funon)(xyz[j])<Float(1,-6),j,NULL),j=1..jmax); nops(%);
Les inverses-in-circle
qqr:= table(): for j to jmax do if ff[j]=1 then next fi;
tmp:= ency(funinv(xyz[j])):
if tmp <>`?` then qqr[j]:= tmp; fi; od: # j:='j':
ici_inv:= sort(map(op,[indices](qqr))); nops(%);
bad_points=seq(`if`(qqr[qqr[j]]=j,NULL,j), j=ici_inv);
tmq: funinv(xyz[1319]): false667:=%/add(k,k=%); map(convert,%,rational);
true667:= xyz[667];map(convert,%,rational);
(reduce@subs)(ency_, pX(667)): %/add(k, k=%);
On doit retrouver le nombre de points sur le cercle
[seq](`if`(qqr[j]=j,j,NULL),j=ici_inv): nops(%);
Les antipodaux
qqr:= table(): for j in ici_on do tmp:= ency(funsym(xyz[j])):
if tmp <>`?` then qqr[j]:= tmp; fi; od: j:='j':
lesk:= sort(map(op,[indices](qqr))); nops(%);
bad_points=seq(`if`(qqr[qqr[j]]=j,NULL,j), j=lesk);
Digits:=10:
Il faut envoyer cela ***si besoin*** dans un r\303\251pertoire lisible et navigable
if false then
try close(fd); catch : end try;
fd := open("/home/douillet/public_html/etc/alt_data.csv", WRITE):
for j in lesk do
fprintf(fd, """%d"";""%d""\134n", j, qqr[j]);
od: close(fd); j:='j':
fi:
<Text-field style="Heading 1" layout="Heading 1">orthocentroidal (new)</Text-field>
j:='j':
cent:= -(reduce@factor)(bary2norm(pX(2))+bary2norm(pX(4))); num_cent:=ency(%);
rad2:= (factor@pytha)(cent, pX(2));
WW3;
(factor@pp2uu)(cent): oc_uu:= (Vector@factor@subs)(defR2,%); ici_uu:=%: ency(%);
subs(rho2=rad2, valR22, zipq(Vector(pu), ici_uu), eq_dou):
eqn0:= sort(collect(%, px, factor, distributed), [x,y,z]);
circlefunction:= subs(y=0,z=0,x=1,eqn0)/b/c;
facxx, facyz:=1/3, 1/3: j:='j':
A(facxx)*Sum( simplify(coeff(eqn0,x,2)/facxx)*x^2,j)+
A(facyz)*Sum(simplify(coeff(coeff(eqn0,y),z)/facyz)*y*z,j):
ici_eqn:= sort(%, [a,b,c,x,y,z]);
(factor@mm2persp@eq2mm)(eqn0): ici_persp:= elimifacu(%); ency(%);
tmp_inv:= bary2norm(cent)+(bary2norm(px)-bary2norm(cent))*rad2/(rad2-eqn0/(x+y+z)^2):
#tmq:= (reduce@factor@evalmm)(%): (Vector@factor@subs)(defR2, %):
#collect(-%/rotp(a^2), px, normal@expand, distributed);
les fonctions funon, funinv, funsym
(reduce@factor@evalmm@subs)(ency_, tmp_inv): funinv:= unapply(%,x,y,z)@op:
(reduce@factor@evalmm@subs)(enzy_, tmp_inv): zuninv:= unapply(%,x,y,z)@op:
funon:= unapply(subs(ency_, eqn0), x,y,z)@op:
(reduce@subs)(ency_, reflection(cent,px)): funsym:= unapply(%,x,y,z)@op:
Bien r\303\251gler le seuil... ou bien passer \303\240 20 chiffres
Digits:=20:
ici_on:= [seq](`if`((abs@funon)(xyz[j])<Float(1,-6),j,NULL),j=1..jmax); nops(%);
Les inverses-in-circle
qqr:= table(): for j to jmax do if ff[j]=1 then next fi;
tmp:= ency(funinv(xyz[j])):
if tmp <>`?` then qqr[j]:= tmp; fi; od: # j:='j':
ici_inv:= sort(map(op,[indices](qqr))); nops(%);
bad_points=seq(`if`(qqr[qqr[j]]=j,NULL,j), j=ici_inv);
for j in ici_inv do zuninv(zxyz[j]); %/add(k,k=%)-zxyz[qqr[j]];
if add(abs(k),k=%) > Float(1,-10) then print(j) fi;
od:
zuninv(zxyz[3528]); evalf(%/add(k,k=%),10);
[-.5595776774, -1.087050205, 2.646627883]
qqr[3544];
On doit retrouver le nombre de points sur le cercle
[seq](`if`(qqr[j]=j,j,NULL),j=ici_inv): nops(%);
Les antipodaux
qqr:= table(): for j in ici_on do tmp:= ency(funsym(xyz[j])):
if tmp <>`?` then qqr[j]:= tmp; fi; od: j:='j':
lesk:= sort(map(op,[indices](qqr))); nops(%);
bad_points=seq(`if`(qqr[qqr[j]]=j,NULL,j), j=lesk);
Digits:=10:
Il faut envoyer cela ***si besoin*** dans un r\303\251pertoire lisible et navigable
if false then
try close(fd); catch : end try;
fd := open("/home/douillet/public_html/etc/alt_data.csv", WRITE):
for j in lesk do
fprintf(fd, """%d"";""%d""\134n", j, qqr[j]);
od: close(fd); j:='j':
fi:
<Text-field style="Heading 1" layout="Heading 1">Fuhrmann (new)</Text-field>
j:='j':
cent:= -(reduce@factor)(bary2norm(pX(4))+bary2norm(pX(8))); num_cent:=ency(%);
rad2:= (factor@pytha)(cent, pX(4));
ruleW:= WW4^2=W4^2;
(sqrt@subs)(ruleW, apbpc, rad2): fuhr_rad:= simplify(%) assuming R>0,W4>0;
(factor@pp2uu)(cent): fuhr_uu:= (Vector@factor@subs)(defR2,%); ici_uu:=%: ency(%);
Plus bo
(FActor@simplify)( subs(apbpc,fuhr_uu), {ruleW}): tmp:= collect(%, [W4, R], factor):;
isolate(ruleW, a^3); collect(subs(%, tmp[3]), [R,W4], factor);
sort(rot(%), [a,b,c]): collect(%, [R,W4], factor): fuhr_uu:= Vector([rot3](%));
(FActor@subs)(defR2, W4=WW4, %-ici_uu);
subs(rho2=rad2, valR22, zipq(Vector(pu), ici_uu), eq_dou):
eqn0:= sort(collect(%, px, factor, distributed), [x,y,z]);
circlefunction:= subs(y=0,z=0,x=1,eqn0)/b/c;
facxx, facyz:=1/(a+b+c) $2: j:='j':
A(facxx)*Sum( simplify(coeff(eqn0,x,2)/facxx)*x^2,j)+
A(facyz)*Sum(simplify(coeff(coeff(eqn0,y),z)/facyz)*y*z,j):
ici_eqn:= sort(%, [a,b,c,x,y,z]);
(factor@mm2persp@eq2mm)(eqn0): ici_persp:= elimifacu(%); ency(%);
tmp_inv:= bary2norm(cent)+(bary2norm(px)-bary2norm(cent))*rad2/(rad2-eqn0/(x+y+z)^2):
#tmq:= (reduce@factor@evalmm)(%): (Vector@factor@subs)(defR2, %):
#collect(-%/rotp(a^2), px, normal@expand, distributed);
les fonctions funon, funinv, funsym
(reduce@factor@evalmm@subs)(ency_, tmp_inv): funinv:= unapply(%,x,y,z)@op:
funon:= unapply(subs(ency_, eqn0), x,y,z)@op:
(reduce@subs)(ency_, reflection(cent,px)): funsym:= unapply(%,x,y,z)@op:
Bien r\303\251gler le seuil... ou bien passer \303\240 20 chiffres
Digits:=20:
ici_on:= [seq](`if`((abs@funon)(xyz[j])<Float(1,-6),j,NULL),j=1..jmax); nops(%);
Les inverses-in-circle
qqr:= table(): for j to jmax do if ff[j]=1 then next fi;
tmp:= ency(funinv(xyz[j])):
if tmp <>`?` then qqr[j]:= tmp; fi; od: # j:='j':
ici_inv:= sort(map(op,[indices](qqr))); nops(%);
bad_points=seq(`if`(qqr[qqr[j]]=j,NULL,j), j=ici_inv);
On doit retrouver le nombre de points sur le cercle
[seq](`if`(qqr[j]=j,j,NULL),j=ici_inv): nops(%);
Les antipodaux
qqr:= table(): for j in ici_on do tmp:= ency(funsym(xyz[j])):
if tmp <>`?` then qqr[j]:= tmp; fi; od: j:='j':
lesk:= sort(map(op,[indices](qqr))); nops(%);
bad_points=seq(`if`(qqr[qqr[j]]=j,NULL,j), j=lesk);
Digits:=10:
Il faut envoyer cela ***si besoin*** dans un r\303\251pertoire lisible et navigable
if false then
try close(fd); catch : end try;
fd := open("/home/douillet/public_html/etc/alt_data.csv", WRITE):
for j in lesk do
fprintf(fd, """%d"";""%d""\134n", j, qqr[j]);
od: close(fd); j:='j':
fi: