lambdaway :: eric

2 | list | login |load

| |

_h2 [[eric_dobbs]] | eric_dobbs2 | [[eric_dobbs3]]

_p A variant for the {b fractal} function.

_h2 1) defining the function

{pre
'{def fractal 
 {lambda {:curv :level :length}
  {if {< :level 1}
   then M:length
   else {S.map {{lambda {:curv :lev :len :command} 
                        {fractal :curv :lev :len} :command
                } :curv {- :level 1} {/ :length 3}}
               {:curv}} 
}}}       
-> {def fractal 
 {lambda {:curv :level :length}
  {if {< :level 1}
   then M:length
   else {S.map {{lambda {:curv :lev :len :command} 
                        {fractal :curv :lev :len} :command
                } :curv {- :level 1} {/ :length 3}}
               {:curv}} 
}}}
}

_p Remember that in lambdatalk lambdas are not closures - see [[lambda]] - and so {b :curv, :level & :length} are unknown to the inner lambda. The workaround is to use an {b IIFE}. Note how the IIFE, {b '{{lambda {args} expression} vals}}, gives the inner 4-ary lambda only 3 values {b :curv, '{- :level 1} & '{/ :length 3}}. It's a partial call generating an anonymous function waiting for the missing one, {b :command}. Then the {b S.map} primitive applies this function to the sequence of commands stored in {b :curv}, a function without arguments called to return the sequence of randomized commands, say "{b T'{- :a} T'{+ :a :a} T'{- :a} T0}".

_p This is a more lisp-like version using two mutually recursive functions.

{pre
'{def fractal

{def fractal.repeat
  {lambda {:curv :lev :len :command}
   {fractal :curv :lev :len} {S.first :command}
   {if {S.empty? {S.rest :command}}
    then 
    else {fractal.repeat :curv 
                         :lev 
                         :len 
                         {S.rest :command}}
 }}}

{lambda {:curv :level :length}       
  {if {< :level 1}
   then M:length
   else {fractal.repeat :curv 
                        {- :level 1} 
                        {/ :length 3} 
                        {:curv}} 
}}}
}

_p Note that {b :curv} is the name of a function and {b '{:curv}} is the sequence of commands, not an array, not a list. Because lambdas are variadic the last argument of the {b fractal.repeat} function accepts a sequence of values. See [[lambda]] for more details on lambdas.

_h2 2) defining some fractal curves

_p We choose to randomize angles and create a function, {b randangle} returning a random value between two values, {b :a & :b}.

{pre
'{def randangle
 {lambda {:a :b}
  {let { {:a :a} {:b :b}    // manual closure (for the poor man)
         {:t {random}} 
       } {+ {* {- 1 :t} :a} {* :t :b}}}}}
-> {def randangle
 {lambda {:a :b}
  {let { {:a :a} {:b :b}
         {:t {random}} 
       } {+ {* {- 1 :t} :a} {* :t :b}}}}}
}

_p Examples

{pre
'{def KOCH
 {lambda {} 
  {let { {:a {randangle -45 45}}
       } T{- :a} T{+ :a :a} T{- :a} T0}}}
-> {def KOCH
 {lambda {} 
  {let { {:a {randangle -45 45}}              
       } T{- :a} T{+ :a :a} T{- :a} T0}}}

'{def PEANO
 {lambda {} 
  {let { {:a {randangle 85 95}}
       } T-:a T:a T:a T:a T-:a T-:a T-:a T:a T0}}}
-> {def PEANO
 {lambda {} 
    {let { {:ang {randangle 85 95}}
         } T-:ang T:ang T:ang T:ang T-:ang T-:ang T-:ang T:ang T0}}}
}

_p In this version commands are given in sequence, out of any array.

_p Writing {b '{fractal KOCH 1 100}} generates the following sequence of commands

{prewrap
{fractal KOCH 1 100}
}

_p which will be transformed by the {b turtle} primitive into a sequence of SVG points, {b x0 y0 x1 y1 ...}

{prewrap
'{turtle 250                    // x origine
         50                    // y origine
          0                    // initial rotation
         {fractal KOCH 1 100}  // the curve
}
-> {turtle 250 50 0 {fractal KOCH 1 100}}
}

_p feeding the {b points} attribute of a SVG polyline to display the curve.

_h2 3) drawings

{pre
'{svg
 {@ width="580" height="580" style="box-shadow:0 0 8px #000;"}

{polyline
  {@ points="{turtle 280 50 0 {fractal PEANO 1 500}}"
     stroke="#888" fill="transparent" stroke-width="5"}}

{polyline
  {@ points="{turtle 280 50 0 {fractal PEANO 3 500}}"
     stroke="#0f0" fill="transparent"}}

{S.map {lambda {}
 {polyline
  {@ points="{turtle 10 100 90 {fractal KOCH 3 250}}"           
     stroke="#f00" fill="transparent"}}       
        } {S.serie 1 5}}

{S.map {lambda {}
 {polyline
  {@ points="{turtle 10 290 90 {fractal KOCH 3 250}}"           
     stroke="#00f" fill="transparent"}}       
        } {S.serie 1 10}}

{polyline
  {@ points="{turtle 10 500 90 {fractal KOCH 3 250}}"           
     stroke="#000" fill="transparent"}}  
}                  
}
         
{svg
 {@ width="580" height="580" style="box-shadow:0 0 8px #000;"}
  
 {polyline
  {@ points="{turtle 280 30 0 {fractal PEANO 1 500}}"
     stroke="#888" fill="transparent" stroke-width="5"}}

{polyline
  {@ points="{turtle 280 030 0 {fractal PEANO 3 500}}"
     stroke="#0f0" fill="transparent"}}

{S.map {lambda {}
 {polyline
  {@ points="{turtle 10 100 90 {fractal KOCH 3 250}}"           
     stroke="#f00" fill="transparent"}}       
        } {S.serie 1 5}}

{S.map {lambda {}
 {polyline
  {@ points="{turtle 10 290 90 {fractal KOCH 3 250}}"           
     stroke="#00f" fill="transparent"}}       
        } {S.serie 1 10}}

{polyline
  {@ points="{turtle 10 500 90 {fractal KOCH 3 250}}"           
     stroke="#000" fill="transparent"}}
}

_p Refresh the page to see variations.

_p {i Alain Marty | 2022/01/01}

_h2 from Eric | 2022/01/03 0:07

{prewrap
Alain,

I think this is pretty much what I was trying to find when I was struggling with my own attempt to port the DrawFractalLine function.

'{def fractal 
 {lambda {:curv :level :length}
  {if {< :level 1}
   then M:length
   else {S.map {{lambda {:curv :lev :len :command} 
                        {fractal :curv :lev :len} :command
                } :curv {- :level 1} {/ :length 3}}
               {:curv}} 
}}}

That's really quite beautiful and it seemed like it was just out of reach when I was working on my own. :-)
I particularly like your simplification here, combined with including a T0 instruction in the :curv -compared to my use of an empty instruction and extra if-statement:
 '{fractal :curv :lev :len} :command

Thank you for the fun new year's present! :-)
-Eric
}

_h2 from alain 2022/01/0313:07

{prewrap
Eric
Thanks.
And thank you also for having opened to me a field of exploration towards the L(indermeyer)-systems. 
The problem is to find the most general function allowing to generate all the families of fractals from simple rules.
Nice walks in sight 
Regards
Alain 
}

{style 
pre { box-shadow:0 0 8px #000; padding:10px; }
}