月: 2022年2月

settings.outformat="pdf";
unitsize(10cm);

pair[] vertex;
vertex = new pair[3];
vertex[0]=(0, 1);

for(int j=1; j<3; ++j) {
vertex[j]= rotate(120, (0,0))* vertex[j-1] ;

}

path a = vertex[0] -- vertex[1] -- vertex[2] --cycle;
draw(a,dashed);
/* dashed*/

pair[] vertex_center;
vertex_center = new pair[3];
for(int j=0; j<3; ++j) {
vertex_center[j]= (1- 0.333333333333333) * vertex[j];
}
dot(vertex_center);

pair p = (vertex[0] + vertex[1] + vertex[2])/3;


pair[] middle;
middle = new pair[3];

for(int j=0; j<3; ++j) {
middle[j]= vertex[j]-p;
}
dot(middle);

pair[] vertex_rot;
vertex_rot = new pair[6];
for(int j=0; j<6; ++j) {
if(j<3){
vertex_rot[j] =vertex[j];
}else
vertex_rot[j] = (3*p + vertex_rot[j-3])/4;
}
dot(middle);

pair comp (pair a, pair b) {\
return (dot(a, reflect((0,0),(1,0))*b),cross(reflect((0,0),(1,0))*a,b));
}

pair[] middle_center;
middle_center = new pair[6];
for(int j=0; j<6; ++j) {
if(j<3){
middle_center[j]= vertex_center[j];
}else
middle_center[j]= vertex_rot[j]+ scale(0.333333333333333)*scale(1/length(middle[j-3]))* comp(comp(middle[j-3],middle[j-3]),reflect((0,0),(1,0))*vertex_rot[j]);
}
dot(middle_center);

path b = scale(0.33333333333)*a;
/*path c = scale(-0.333333333333333)*scale(1/length(middle[j-3]))* comp(comp(middle[j-3],middle[j-3]),reflect((0,0),(1,0))*a); */


path[] ver_path;
ver_path = new path[6];
ver_path[0] =shift(middle_center[0])*scale(0.33333333333)*a;
for(int j=1; j<6; ++j) {
if(j<3){
ver_path[j] =rotate(120,(0,0))*ver_path[j-1];
}else
ver_path[j] = reflect(point(ver_path[j-3],1),point(ver_path[j-3],2))*ver_path[j-3];
}
draw(ver_path);

path[][] contra;
contra = new path[6][6];

for(int j=0; j<6; ++j) {
for(int i=0; i<6; ++i) {
if(i<3){
contra[i][j]= shift(middle_center[i])*scale(0.33333)* ver_path[j];
}else{
contra[i][j]= reflect(point(ver_path[i-3],1),point(ver_path[i-3],2))*contra[i-3][j];
}
draw(contra[i][j],dashed);
}
}

path[][][] contra2;
contra2 = new path[6][6][6];

for(int k=0; k<6; ++k) {
for(int j=0; j<6; ++j) {
for(int i=0; i<6; ++i) {
if(i<3){
contra2[i][j][k]= shift(middle_center[i])*scale(0.33333)* contra[j][k];
}else{
contra2[i][j][k]= reflect(point(ver_path[i-3],1),point(ver_path[i-3],2))*contra2[i-3][j][k];
}
draw(contra2[i][j][k],dashed);
}
}
}

path[][][][] contra3;
contra3 = new path[6][6][6][6];

for(int l=0; l<6; ++l) {
for(int k=0; k<6; ++k) {
for(int j=0; j<6; ++j) {
for(int i=0; i<6; ++i) {
if(i<3){
contra3[i][j][k][l]= shift(middle_center[i])*scale(0.33333)* contra2[j][k][l];
}else{
contra3[i][j][k][l]= reflect(point(ver_path[i-3],1),point(ver_path[i-3],2))*contra3[i-3][j][k][l];
}
draw(contra3[i][j][k][l],dashed);
}
}
}
}

path[][][][][] contra4;
contra4 = new path[6][6][6][6][6];

for(int m=0; m<6; ++m) {
for(int l=0; l<6; ++l) {
for(int k=0; k<6; ++k) {
for(int j=0; j<6; ++j) {
for(int i=0; i<6; ++i) {
if(i<3){
contra4[i][j][k][l][m]= shift(middle_center[i])*scale(0.33333)* contra3[j][k][l][m];
}else{
contra4[i][j][k][l][m]= reflect(point(ver_path[i-3],1),point(ver_path[i-3],2))*contra4[i-3][j][k][l][m];
}
draw(contra4[i][j][k][l][m],dashed);
}
}
}
}
}

path[][][][][][] contra5;
contra5 = new path[6][6][6][6][6][6];

for(int n=0; n<6; ++n) {
for(int m=0; m<6; ++m) {
for(int l=0; l<6; ++l) {
for(int k=0; k<6; ++k) {
for(int j=0; j<6; ++j) {
for(int i=0; i<6; ++i) {
if(i<3){
contra5[i][j][k][l][m][n]= shift(middle_center[i])*scale(0.33333)* contra4[j][k][l][m][n];
}else{
contra5[i][j][k][l][m][n]= reflect(point(ver_path[i-3],1),point(ver_path[i-3],2))*contra5[i-3][j][k][l][m][n];
}
draw(contra5[i][j][k][l][m][n]);
}
}
}
}
}

settings.outformat="pdf";
unitsize(10cm);
pair p1=(0, -1), p2 = (0.8660254037844, -0.5), p3 =(0.8660254037844, 0.5), p4 = (0, 1), p5 = (-0.8660254037844, 0.5), p6 = (-0.8660254037844, -0.5) ;
path a = p1 -- p2 -- p3 -- p4 -- p5 -- p6 --cycle;
draw(a, dashed);
/* draw(rotate(60)*a, purple);*/ /*Rotate 60degrees*/
/* pair q_1 = (-0.321358865654623, -0.36561928865444946);*/

path b= scale(0.25)*a;
/* draw(b,red +dashed); */

pair q1 = scale(0.75) * p1;
draw(q1);
path b1= shift(q1)*b;

pair q2 = scale(0.75) * p2;
draw(q2);
path b2= shift(q2)*b;

pair q3 = scale(0.75) * p3;
draw(q3);
path b3= shift(q3)*b;


pair q4 = scale(0.75) * p4;
draw(q4);
path b4= shift(q4)*b;

pair q5 = scale(0.75) * p5;
draw(q5);
path b5= shift(q5)*b;

pair q6 = scale(0.75) * p6;
draw(q6);
path b6= shift(q6)*b;

pair d1 = (-0.21650635094,-0.375);
draw(d1);
path e1= shift(d1)*b;

pair d2 = (0.21650635094,-0.375);
draw(d2);
path e2= shift(d2)*b;

pair d3 = (0.4330127018922,0);
draw(d3);
path e3= shift(d3)*b;

pair d4 = (0.21650635094,0.375);
draw(d4);
path e4= shift(d4)*b;

pair d5 = (-0.21650635094,0.375);
draw(d5);
path e5= shift(d5)*b;


pair d6 = (-0.4330127018922,0);
draw(d6);
path e6= shift(d6)*b;

path[] pre;
pre = new path[12];

path[] intersect= {b1, b2, b3, b4, b5,b6, e1, e2,e3, e4, e5, e6};
pair[] fixedpoint = {p1, p2, p3, p4, p5,p6};
pair[] col = {q1, q2, q3, q4, q5,q6, d1, d2, d3, d4, d5,d6};

for(int j=0; j<12; ++j) {
pre[j]= scale(0.25)* intersect[j];

}
/* draw(pre[j],red+dashed); */

path[][] contra;
contra = new path[12][12];

for(int j=0; j<12; ++j) {
for(int i=0; i<12; ++i) {
contra[i][j]= shift(col[i])* pre[j];

}
}
/* draw(contra[i][j],dashed);fill(contra[i][j]); */

pen[] color = {paleblue, palegreen, paleyellow, palecyan,palered, palemagenta};
color.cyclic=true;


path[][][] contra_contra;
contra_contra = new path[12][12][12];

for(int k=0; k<12; ++k) {
for(int j=0; j<12; ++j) {
for(int i=0; i<12; ++i) {
contra_contra[i][j][k] = shift(col[i])*scale(0.25)*contra[j][k] ;
draw(contra_contra[i][j][k]);
}
}
}
/*draw(contra_contra[3][3][0],red); draw(contra_contra[i][j][k]); fill(contra_contra[i][j][k], color[j]);*/

settings.outformat="pdf";
unitsize(10cm);

pair[] vertex;
vertex = new pair[3];
vertex[0]=(0,1);
for(int j=1; j<3; ++j) {
vertex[j]= rotate(120, (0,0))* vertex[j-1] ;

}

path a = vertex[0] -- vertex[1] -- vertex[2] --cycle;
draw(a,dashed);
/* dashed*/

pair[] vertex_center;
vertex_center = new pair[3];
for(int j=0; j<3; ++j) {
vertex_center[j]= (1- 0.5) * vertex[j];
}
dot(vertex_center);


path b= scale(0.5)*a;
/* draw(b,dashed); */


path[] ver_path;
ver_path = new path[3];

for(int j=0; j<3; ++j) {
ver_path[j]= shift(vertex_center[j])*b;
draw(ver_path[j],dashed);
}
/* */

path[] pre;
pre = new path[3];

for(int i=0; i<3; ++i){
pre[i]= scale(0.5)*ver_path[i];
}


path[][] contra;
contra = new path[3][3];

for(int j=0; j<3; ++j) {
for(int i=0; i<3; ++i) {
contra[i][j]= shift(vertex_center[i])* pre[j];
draw(contra[i][j],dashed);
}
}

path[][][] contra_contra;
contra_contra = new path[3][3][3];

for(int j=0; j<3; ++j) {
for(int i=0; i<3; ++i) {
for(int k=0; k<3; ++k){
contra_contra[i][j][k]= shift(vertex_center[i])*scale(0.5)* contra[j][k];
draw(contra_contra[i][j][k],dashed);
}
}
}

path[][][][] contra_3;
contra_3 = new path[3][3][3][3];

for(int j=0; j<3; ++j) {
for(int i=0; i<3; ++i) {
for(int k=0; k<3; ++k){
for(int l=0; l<3; ++l){
contra_3[i][j][k][l]= shift(vertex_center[i])*scale(0.5)* contra_contra[j][k][l];
draw(contra_3[i][j][k][l],dashed);
}
}
}
}

path[][][][][] contra_4;
contra_4 = new path[3][3][3][3][3];

for(int j=0; j<3; ++j) {
for(int i=0; i<3; ++i) {
for(int k=0; k<3; ++k){
for(int l=0; l<3; ++l){
for(int m=0; m<3; ++m){
contra_4[i][j][k][l][m]= shift(vertex_center[i])*scale(0.5)* contra_3[j][k][l][m];
draw(contra_4[i][j][k][l][m],dashed);
}
}
}
}
}

path[][][][][][] contra_5;
contra_5 = new path[3][3][3][3][3][3];

for(int j=0; j<3; ++j) {
for(int i=0; i<3; ++i) {
for(int k=0; k<3; ++k){
for(int l=0; l<3; ++l){
for(int m=0; m<3; ++m){
for(int n=0; n<3; ++n){
contra_5[i][j][k][l][m][n]= shift(vertex_center[i])*scale(0.5)* contra_4[j][k][l][m][n];
fill(contra_5[i][j][k][l][m][n],dashed);
}
}
}
}
}
}

# -*- coding: utf-8 -*-
#sierpinskigasket.py
import numpy as np


# ベクトル回転関数
# deg=Falseならばラジアンで角度を指定
# deg=Trueならば度数単位で角度を指定
def rotation_o(u, t, deg=False):

# 度数単位の角度をラジアンに変換
if deg == True:
t = np.deg2rad(t)

# 回転行列
R = np.array([[np.cos(t), -np.sin(t)],
[np.sin(t), np.cos(t)]])

return np.dot(R, u)

maxlevel = 8 #再帰の回数

def gasket(x10, y10, x20, y20, x30, y30, level):
if level == maxlevel:
print(x10, y10)
print(x20, y20, "\n")
print(x20, y20)
print(x30, y30, "\n")
print(x30, y30)
print(x10, y10, "\n")
return
else:
x11, y11 = (x20+x30)/2.0, (y20+y30)/2.0
x21, y21 = (x30+x10)/2.0, (y30+y10)/2.0
x31, y31 = (x10+x20)/2.0, (y10+y20)/2.0

x12, y12 = (4* x11 + 1* x21)/5, (4* y11 + 1* y21)/5
x22, y22 = (4* x21 + 1* x31)/5, (4* y21 + 1* y31)/5
x32, y32 = (4* x31 + 1* x11)/5, (4* y31 + 1* y11)/5
# print(x12, y12)
# print(0, 0, "\n")
print(x12, y12)
print(x22, y22, "\n")
print(x12, y12)
print(x32, y32, "\n")
print(x22, y22)
print(x32, y32, "\n")
gasket(x10,y10, x31, y31, x21, y21, level + 1)
gasket(x31,y31, x20, y20, x11, y11, level + 1)
gasket(x21,y21, x11, y11, x30, y30, level + 1)

gasket(x12,y12, x22, y22, x32, y32, level + 1)

x10, y10, x20, y20, x30, y30, level = 0.0, 0.0, 1.0, 0.0, 0.5, 1.0, 0
gasket(x10, y10, x20, y20, x30, y30, level)

Hata_like_tree

settings.outformat="pdf";
unitsize(10cm);

pair[] vertex;
vertex = new pair[3];
vertex[0]=(0.4,0.3);
vertex[1]=(0,0);
vertex[2]=(1,0);


path a = vertex[0] -- vertex[1] -- vertex[2] ;


dot(vertex);

transform U = (0,0, 0.4,-0.3,0.3,0.4);
/*
pair[] c_vertex;
c_vertex = new pair[3];

for(int i=0; i<3; ++i) {
c_vertex[i]=conj(vertex[i]);
}

path c = c_vertex[0] -- c_vertex[1] -- c_vertex[2] ;*/
/*draw(c,red); */

path d = U* reflect((0,0), (1,0))*a;
draw(d,blue);

path e= shift(0.25, 0)*scale(0.75)*reflect((0,0), (1,0))*a;
draw(e);
dot(e);


path[] pre;
pre = new path[2];

pre[0]= d ;
pre[1]= e ;

path[] hata1;
hata1 = new path[4];


for(int i=0; i<2; ++i){
hata1[i]= U* reflect((0,0), (1,0))*pre[i];
}
for(int i=2; i<4; ++i){
hata1[i]= shift(0.25, 0)*scale(0.75)*reflect((0,0), (1,0))*pre[i-2];
}
draw(hata1);


path[] hata2;
hata2 = new path[8];

for(int i=0; i<4; ++i){
hata2[i]= U* reflect((0,0), (1,0))*hata1[i];
}
for(int i=4; i<8; ++i){
hata2[i]= shift(0.25, 0)*scale(0.75)*reflect((0,0), (1,0))*hata1[i-4];
}
draw(hata2);

path[] hata3;
hata3 = new path[16];

for(int i=0; i<8; ++i){
hata3[i]= U* reflect((0,0), (1,0))*hata2[i];
}
for(int i=8; i<16; ++i){
hata3[i]= shift(0.25, 0)*scale(0.75)*reflect((0,0), (1,0))*hata2[i-8];
}
draw(hata3);

path[] hata4;
hata4 = new path[32];

for(int i=0; i<16; ++i){
hata4[i]= U* reflect((0,0), (1,0))*hata3[i];
}
for(int i=16; i<32; ++i){
hata4[i]= shift(0.25, 0)*scale(0.75)*reflect((0,0), (1,0))*hata3[i-16];
}
draw(hata4);

path[] hata5;
hata5 = new path[64];

for(int i=0; i<32; ++i){
hata5[i]= U* reflect((0,0), (1,0))*hata4[i];
}
for(int i=32; i<64; ++i){
hata5[i]= shift(0.25, 0)*scale(0.75)*reflect((0,0), (1,0))*hata4[i-32];
}
draw(hata5);

path[] hata6;
hata6 = new path[128];

for(int i=0; i<64; ++i){
hata6[i]= U* reflect((0,0), (1,0))*hata5[i];
}
for(int i=64; i<128; ++i){
hata6[i]= shift(0.25, 0)*scale(0.75)*reflect((0,0), (1,0))*hata5[i-64];
}
draw(hata6);

path[] hata7;
hata7 = new path[256];

for(int i=0; i<128; ++i){
hata7[i]= U* reflect((0,0), (1,0))*hata6[i];
}
for(int i=128; i<256; ++i){
hata7[i]= shift(0.25, 0)*scale(0.75)*reflect((0,0), (1,0))*hata6[i-128];
}
draw(hata7);

path[] hata8;
hata8 = new path[512];

for(int i=0; i<256; ++i){
hata8[i]= U* reflect((0,0), (1,0))*hata7[i];
}
for(int i=256; i<512; ++i){
hata8[i]= shift(0.25, 0)*scale(0.75)*reflect((0,0), (1,0))*hata7[i-256];
}
draw(hata8);

path[] hata9;
hata9 = new path[1024];

for(int i=0; i<512; ++i){
hata9[i]= U* reflect((0,0), (1,0))*hata8[i];
}
for(int i=512; i<1024; ++i){
hata9[i]= shift(0.25, 0)*scale(0.75)*reflect((0,0), (1,0))*hata8[i-512];
}
draw(hata9);

path[] hata10;
hata10 = new path[2048];

for(int i=0; i<1024; ++i){
hata10[i]= U* reflect((0,0), (1,0))*hata9[i];
}
for(int i=1024; i<2048; ++i){
hata10[i]= shift(0.25, 0)*scale(0.75)*reflect((0,0), (1,0))*hata9[i-1024];
}
draw(hata10);

path[] hata11;
hata11 = new path[4096];

for(int i=0; i<2048; ++i){
hata11[i]= U* reflect((0,0), (1,0))*hata10[i];
}
for(int i=2048; i<4096; ++i){
hata11[i]= shift(0.25, 0)*scale(0.75)*reflect((0,0), (1,0))*hata10[i-2048];
}
draw(hata11);

path[] hata12;
hata12 = new path[4096];

for(int i=0; i<4096; ++i){
hata12[i]= U* reflect((0,0), (1,0))*hata11[i];
}
for(int i=4096; i<8192; ++i){
hata12[i]= shift(0.25, 0)*scale(0.75)*reflect((0,0), (1,0))*hata11[i-4096];
}
draw(hata12);


/* draw(a); dashed*/