lambdaway :: sierpinsky

6 | list | login |load

| |

{{block}
_h1 sierpinsky {sup ([[triangle|?view=sierpinsky]] | carpet {sup ([[2|?view=sierpinsky2]]|[[3|?view=sierpinsky3]]|[[4|?view=sierpinsky4]]|[[5|?view=sierpinsky5]]|[[6|?view=sierpinsky6]]|[[7|?view=sierpinsky7]])}}

_p Diverses versions du carré de Sierpinsky.

_ul [[http://larryriddle.agnesscott.org/ifs/siertri/siertri.htm|http://larryriddle.agnesscott.org/ifs/siertri/siertri.htm]]
_ul [[https://scratch.mit.edu/projects/68354132/remixes/|https://scratch.mit.edu/projects/68354132/remixes/]]
_ul [[rosettacode.org|https://rosettacode.org/wiki/Sierpinski_carpet]]
_ul [[pascal]]

_h2 more 
_p The Sierpinsky's hexagonal carpet can be seen as a composition of 6 Sierpinsky's triangles, as shown in the page [[triangle|?view=sierpinsky]].

_img http://larryriddle.agnesscott.org/ifs/siertri/SierHexagonLarge3.gif

}

{{block}
_h2 javascript, version 1

{pre
'{pre
 {@ style='font-family:monaco;
           line-height:0.6em;'}
  {S.map sierp1 0 1 2 3}

} 
}

_p affiche

{pre {@ style='font-family:monaco; line-height:0.6em;'}
{S.map sierp1 0 1 2 3}
}

_p avec ce code javascript:

{pre °°
var SIERP1 = (function() {

var bool = function(x,y) {
      if (x==0 || y==0)
        return true
      else if ((x%3==1) && (y%3==1))
        return false
      else
        return bool(Math.floor(x/3),Math.floor(y/3))
  };

var draw = function(b) {
    return (b) ? "■" : " " 
  };

var compute = function(n) {
    var res="{h3 S" + n + "}";
    var power = Math.pow(3,n);

for (var i=0; i< power; i++) {
      for (var j=0; j< power; j++)
        res += draw( bool(i,j) );   
      res += "{div}"
    }
    return res
  };

return { val:compute }
})()

// interface avec lambdatalk :

LAMBDATALK.DICT["sierp1"] = function() {
  return SIERP1.val( arguments[0].trim() )
};

°°}
}

{{block}
_h2 javascript, version 2

{pre
'{pre
 {@ style='font-family:monaco;
           line-height:0.6em;'}
  {S.map sierp2 0 1 2 3}

} 
}

_p affiche

{pre {@ style='font-family:monaco; line-height:0.6em;'}
{S.map sierp2 0 1 2 3}
}

_p avec ce code javascript:

{pre °°
var SIERP2 = (function() {
  var charmap = [];

function Motif(taille) {
	Clone(1, 0, taille);
	Clone(2, 0, taille);
	Clone(0, 1, taille);
	Trou(1, 1, taille);
	Clone(2, 1, taille);
	Clone(0, 2, taille);
	Clone(1, 2, taille);
	Clone(2, 2, taille);
  }

function Trou(idest, jdest, cote) {
	xdest = idest * cote;
	ydest = jdest * cote;
	for (var iligne=0; iligne < cote; iligne++) {
		acopier = ".".repeat(cote);
		console.log(idest + "-" + ydest + "-" +acopier)
		charmap[ydest + iligne] += acopier;
	}
  }

function Init(nbiter) {
	var textaff = "{h3 S" + nbiter + "}";
        var cote = 1
	
        charmap[0] = "■";

for( var prof=0; prof< nbiter; prof++) {
		Motif(cote);
		cote *= 3;
	}
	for (var iligne=0; iligne < cote; iligne++) {
		textaff += charmap[iligne] + "{div}";
	}
	return textaff.replace( /\./g, " ") ;  // . -> espaces
  }

return { val:Init }
})();

// interface avec lambdatalk :

LAMBDATALK.DICT["sierp2"] = function() {
   return SIERP2.val( arguments[0].trim() )
};
°°}
}

{{block}
_h2 lambdatalk, version 1

{pre
'{pre
 {@ style='font-family:monaco;
           line-height:0.6em;'}
  {S.map sierp3 0 1 2}

} 
}

_p affiche

{pre {@ style='font-family:monaco; line-height:0.6em;'}
{S.map sierp3 0 1 2 3}
}

_p avec ce code lambdatalk:

{pre
'{def sierp3

{def sierp3.r
  {lambda {:n :w}
   {if {= :n 0}
    then :w
    else {sierp3.r 
          {- :n 1}
          {S.map {lambda {:x} :x:x:x} :w}
          {S.map {lambda {:x} :x{S.replace ■ by o in :x}:x} :w}  
          {S.map {lambda {:x} :x:x:x} :w} }}}}

{lambda {:n}
  {h3 S:n}{S.replace o by space in 
            {S.replace \s by {div} in 
             {sierp3.r :n ■}}}{div}}}
-> {def sierp3

{lambda {:n}
  {h3 S:n}{S.replace o by space in 
            {S.replace \s by {div} in 
             {sierp3.r :n ■}}}{div}}}
}

_p Note sur les primitives lambdatalk {b S.map & S.replace}

{pre
'{S.map {lambda {:x} :x:x:x} ■■■ooo■■■}
-> {S.map {lambda {:x} :x:x:x} ■■■ooo■■■}

'{S.replace o by space in ■■■ooo■■■■■■ooo■■■■■■ooo■■■}
-> {S.replace o by space in ■■■ooo■■■■■■ooo■■■■■■ooo■■■}
}

_p La fonction récursive {b sierp3.r} est en fait une itération appliquant n fois le processus défini par

{pre
'{S.map {lambda {:x} :x:x:x} :w}
'{S.map {lambda {:x} :x{S.replace ■ by o in :x}:x} :w}  
'{S.map {lambda {:x} :x:x:x} :w}
}

_p qui, appliqué sur le motif S2, peut se lire ainsi

_ul 1) prend S2, où les espaces sont matérialisés par des "o"
_ul 2) assemble 3 copies de S2 et passe à la ligne
_ul 3) assemble 3 copies de S2, dont celle du milieu est remplacée par des "o", et passe à la ligne
_ul 4) assemble 3 copies de S2
_ul 5) remplace les "o" par des espaces, on obtient S3

_p La fonction {b sierp3} appelle {b sierp3.r} et nettoie/formate la chaine résultante.

{pre {@ style='font-family:monaco; line-height:0.6em;'}
{sierp3 4}
}
}

{{block}
_h2 lambdatalk, version 2

{pre
'{svg {@ width="580" height="580" style="background:#000"}
 {g {@ transform=translate(0,0)}     {sierp4 300 0}}
 {g {@ transform=translate(300,0)}   {sierp4 300 1}}
 {g {@ transform=translate(300,300)} {sierp4 300 2}}
 {g {@ transform=translate(0,300)}   {sierp4 300 3}}
}
}

_p affiche

{svg {@ width="600" height="600" style="background:#000"}
 {g {@ transform=translate(0,0)} {sierp4 300 0}}
 {g {@ transform=translate(300,0)} {sierp4 300 1}}
 {g {@ transform=translate(300,300)} {sierp4 300 2}}
 {g {@ transform=translate(0,300)} {sierp4 300 3}}
}

_p avec ce code lambdatalk/SVG

{pre
'{def sierp4

{def sierp4.square
  {lambda {:x :y :w}
   {rect {@ x="{- :x {/ :w 2}}" 
            y="{- :y {/ :w 2}}" 
            width=":w" height=":w"
            fill="#000"}}}}

{def sierp4.pattern
  {lambda {:x :y :w :n}
   {sierp4.square :x :y :w}   
   {sierp4.recurse {- :x :w} {- :y :w} :w :n}
   {sierp4.recurse    :x     {- :y :w} :w :n}
   {sierp4.recurse {+ :x :w} {- :y :w} :w :n}
   {sierp4.recurse {+ :x :w}    :y     :w :n}
   {sierp4.recurse {+ :x :w} {+ :y :w} :w :n}
   {sierp4.recurse    :x     {+ :y :w} :w :n}
   {sierp4.recurse {- :x :w} {+ :y :w} :w :n}
   {sierp4.recurse {- :x :w}    :y     :w :n} }}

{def sierp4.recurse
  {lambda {:x :y :w :n}
   {if {< :n 0}
    then   
    else {sierp4.pattern :x :y {/ :w 3} {- :n 1}} }}}

{lambda {:w  :n}
  {sierp4.recurse {/ :w 2} {/ :w 2} :w :n} }}

-> {def sierp4

{def sierp4.square
  {lambda {:x :y :w}
   {rect {@ x="{- :x {/ :w 2}}" 
            y="{- :y {/ :w 2}}" 
            width=":w" height=":w"
            fill="#fff"}}}}

{def sierp4.recurse
  {lambda {:x :y :w :n}
   {if {< :n 0}
    then   
    else {sierp4.pattern :x :y {/ :w 3} {- :n 1}} }}}

{lambda {:w  :n}
  {sierp4.recurse {/ :w 2} {/ :w 2} :w :n} }} 
}

}

{{hide}
{def display pre {@ style='font-family:monaco; line-height:0.6em;'}}

{def block 
  div {@ style="display:inline-block; width:600px; background:#eee;
                vertical-align:top; padding:5px; "}}
}

{style 
#page_content { width:3200px; }
#page_frame   { width:600px; margin-left:0; }
pre { background:#fff; padding:5px; }
}

{script 
var SIERP1 = (function() {

var bool = function(x,y) {
      if (x==0 || y==0)
        return true
      else if ((x%3==1) && (y%3==1))
        return false
      else
        return bool(Math.floor(x/3),Math.floor(y/3))
  };

var draw = function(b) {
    return (b) ? "■" : " " 
  };

var compute = function(n) {
    var res="{h3 S" + n + "}";
    var power = Math.pow(3,n);

for (var i=0; i< power; i++) {
      for (var j=0; j< power; j++)
        res += draw( bool(i,j) );   
      res += "{div}"
    }
    return res
  };

return { val:compute }
})()

// interface avec lambdatalk :

LAMBDATALK.DICT["sierp1"] = function() {
  return SIERP1.val( arguments[0].trim() )
};

var SIERP2 = (function() {
  var charmap = [];

function Init(nbiter) {
	var textaff = "{h3 S" + nbiter + "}";
        var cote = 1
	
        charmap[0] = "■";

return { val:Init }
})();

// interface avec lambdatalk :

LAMBDATALK.DICT["sierp2"] = function() {
   return SIERP2.val( arguments[0].trim() )
};

}