Page 1 of 1

a neat picture based on recursive number

Posted: Mon Sep 03, 2018 11:17 pm UTC
by phillip1882
https://ibb.co/kPRY2z
this picture represents the first 4000 numbers in recursive format.
<> 2
<<>> 3
<><>4
<<<>>> 5
and so on
the left arrow turns the turtle left 30 degrees then moves forward 5 and the right arrow rotate right 60 degrees and then move forward 5
heres the python code that produced it

Code: Select all

import turtle
recurse = [""]*1000000
recurse[2] = "<>"
n = 2
p = 1
while n < len(recurse):
   for v in range(2,int(len(recurse)/n)):
      if recurse[v] != "":
         recurse[v*n] = recurse[v] +recurse[n]
    
   n += 1
   while n<len(recurse) and recurse[n] != "":
      n += 1
   if n == len(recurse):
      break
   p += 1
   recurse[n] = "<" +recurse[p] +">"
turtle.screensize(7000,4500)
turtle.up()   
turtle.sety(-200)
turtle.down()
for i in range(2,len(recurse)):
   for j in range(0,len(recurse[i])):
      if recurse[i][j] == ">":
         turtle.right(60)
         turtle.forward(5)
      else:
         turtle.left(30)
         turtle.forward(5)
   print(recurse[i],i)
input()

Re: a neat picture based on recursive number

Posted: Wed Sep 05, 2018 5:55 am UTC
by Xanthir
First, neat picture! It's always cool to see the kind of emergent patterns that come out of simple rules like this.

Second, the few numbers you provided give *no* clue as to the pattern you're following. I had to puzzle thru your Python to figure it out instead. From what I can tell, the pattern is:

1. The 1st pattern, P₁, is the empty string.
2. If n is the mth prime, then Pₙ = "<" + Pₘ + ">". (So, since 2 is the 1st prime, P₂ = <>, which is P₁ wrapped in angle brackets. 3 is the 2nd prime, so it's <<>>, P₂ wrapped. 5 is P₃ wrapped, 7 is P₄ wrapped, 11 is P₅ wrapped, etc.)
3. If n is composite, it can be divided into its smallest prime factor j and the rest of the number k. Pₙ is then Pₖ+Pⱼ. (So P₄ is P₂+P₂ <><>, P₁₂ is P₄+P₃ <><><<>>, P₁₀₀ is P₅₀+P₂, etc.)

Third, your use of single-letter variables and some slightly unidiomatic Python made it a bit hard to follow. I've rewritten it here to help myself understand:

Code: Select all

#!/usr/bin/env python2
def generatePatterns(limit):
   patterns = [""] * limit
   prime = 2
   primeCount = 1
   while prime < limit:
      # If N is the Mth prime, generate its pattern from the Mth pattern.
      patterns[prime] = "<" + patterns[primeCount] + ">"
      # Generate patterns for every possible multiple of prime
      # from the Prime'th pattern
      # and the Multiplier'th pattern
      for mult in xrange(2): # we won't use the whole range
         if mult*prime >= limit:
            break
         if patterns[multiplier]:
            patterns[multiplier*newPrime] = patterns[multiplier] + patterns[newPrime]
      # Now find the next prime.
      # Per Eratosthene's sieve, this is just the next unfilled value.
      while prime < limit and patterns[prime]:
         prime += 1
      primeCount += 1
   return patterns

def drawPatterns(patterns):
   import turtle
   turtle.screensize(7000,4500)
   turtle.up()
   turtle.sety(-200)
   turtle.down()
   for pattern in patterns:
      for command in pattern:
         if command == ">":
            turtle.right(60)
            turtle.forward(5)
         else:
            turtle.left(30)
            turtle.forward(5)
      print(pattern,i)

drawPatterns(generatePatterns(10**6))


I haven't run this, but I think it works? Is this code clear to you?

Re: a neat picture based on recursive number

Posted: Wed Sep 05, 2018 5:31 pm UTC
by phillip1882
some small mistakes you made, i corrected them. mostly just using variables without declaring them

Code: Select all

def generatePatterns(limit):
   patterns = [""] * limit
   prime = 2
   primeCount = 1
   while prime < limit:
      # If N is the Mth prime, generate its pattern from the Mth pattern.
      patterns[prime] = "<" + patterns[primeCount] + ">"
      # Generate patterns for every possible multiple of prime
      # from the Prime'th pattern
      # and the Multiplier'th pattern
      for mult in range(2,len(patterns)): # we won't use the whole range
         if mult*prime >= limit:
            break
         if patterns[mult]:
            patterns[mult*prime] = patterns[mult] + patterns[prime]
      # Now find the next prime.
      # Per Eratosthene's sieve, this is just the next unfilled value.
      while prime < limit and patterns[prime]:
         prime += 1
      primeCount += 1
   return patterns


def drawPatterns(patterns):
   import turtle
   turtle.screensize(7000,4500)
   turtle.up()
   turtle.sety(-200)
   turtle.down()
   i = 0
   for pattern in patterns:
      for command in pattern:
         if command == ">":
            turtle.right(60)
            turtle.forward(5)
         else:
            turtle.left(30)
            turtle.forward(5)
      print(pattern,i)
      i+=1
drawPatterns(generatePatterns(10**6))

Re: a neat picture based on recursive number

Posted: Thu Sep 06, 2018 6:35 pm UTC
by FlatAssembler
Didn't know Python supported turtle graphics, thanks for informing me.
Anyway, I've done a similar thing in JavaScript about a year ago. You can see it here. Though, admittedly, your looks even better.

Re: a neat picture based on recursive number

Posted: Sat Sep 08, 2018 3:31 am UTC
by PM 2Ring
Also see Dyck words.
In the theory of formal languages of computer science, mathematics, and linguistics, a Dyck word is a balanced string of square brackets [ and ]. The set of Dyck words forms Dyck language.

Dyck words and language are named after the mathematician Walther von Dyck. They have applications in the parsing of expressions that must have a correctly nested sequence of brackets, such as arithmetic or algebraic expressions.

Re: a neat picture based on recursive number

Posted: Sat Sep 08, 2018 12:01 pm UTC
by phlip
See also this thread over in Forum Games, which I suspect the OP is familiar with, but might not be familiar to others reading this thread...

Re: a neat picture based on recursive number

Posted: Wed Sep 12, 2018 4:16 pm UTC
by Xanthir
Ah, indeed! I hadn't quite fully gathered the recursive nature there. So you're expressing a number solely by using the nth-prime() function, multiplication, and the number 1. For compactness, nth-prime(arg) is instead written as <arg>, multiplication is implicit from concatenation, and 1 can be omitted because it only and always appears at the deepest nesting of a <>. So 7 is nth-prime(4), aka nth-prime(2*2), aka nth-prime(nth-prime(1) * nth-prime(1)), and this can then be compacted to <<><>>.

Re: a neat picture based on recursive number

Posted: Wed Sep 12, 2018 10:42 pm UTC
by phillip1882
https://ibb.co/dxoNzp
another one for fun. its red for an even number of prime factors and blue for odd. its also toroidal, it wraps around the edges. also i made the right 45 rather than 60, and forward 3 rather than 5
this picture is roughly 1/4 the whole image.

Code: Select all

import time
import turtle

recurse = [""]*1000000
recurse[2] = "<>"
n = 2
p = 1
while n < len(recurse):
   for v in range(2,int(len(recurse)/n)):
      if recurse[v] != "":
         recurse[v*n] = recurse[v] +recurse[n]
    
   n += 1
   while n<len(recurse) and recurse[n] != "":
      n += 1
   if n == len(recurse):
      break
   p += 1
   recurse[n] = "<" +recurse[p] +">"
turtle.screensize(2000,2000)
turtle.up()   
turtle.sety(-200)
turtle.down()
turtle.speed(0)
turtle.hideturtle()
for i in range(2,len(recurse)):
   for j in range(0,len(recurse[i])):
      x,y = turtle.position()
      if x < -1000:
         turtle.up()
         turtle.setx(1000)
         turtle.down()
      elif x > 1000:
         turtle.up()
         turtle.setx(-1000)
         turtle.down()
      if y <-1000:
         turtle.up()
         turtle.sety(1000)
         turtle.down()
      elif y > 1000:
         turtle.up()
         turtle.sety(-1000)
         turtle.down()
      middle = 0
      total = 0
      for k in range(0,len(recurse[i])):
         if recurse[i][k] == "<":
            middle += 1
         else:
            middle -= 1
         if middle == 0:
            total +=1
      if total&1 == 0:
         turtle.color("red")
      else:
         turtle.color("blue")
      if recurse[i][j] == ">":
         turtle.right(45)
         turtle.forward(3)
      else:
         turtle.left(30)
         turtle.forward(3)
 
    
   print(recurse[i],i)
time.sleep(86400)
input()

Re: a neat picture based on recursive number

Posted: Fri Sep 21, 2018 2:59 am UTC
by phillip1882
https://ibb.co/bYDXKz

this one is green for squares or multiple of squares. this picture is after roughly 2000. i don't think posting the code is necessary, its fairly straight forward

Re: a neat picture based on recursive number

Posted: Sun Sep 23, 2018 9:37 pm UTC
by phillip1882
final one: the result after 200,000 approximately, it mostly just looks like a random plot
https://ibb.co/ff53Gp

Re: a neat picture based on recursive number

Posted: Mon Sep 24, 2018 8:47 am UTC
by Soupspoon
"Looks like a random plot" is at one end of a spectrum of expectations. "Looks exactly like it's what you put in" is at the other end.

Unless you're looking for that kind "procedural fuzziness" output to produce (reproducable, arbitrarily detailed 'naturalistic' distribtions at will, the more interesting ones are in the middle. They don't look "random" but they have no obvious relationship with the specification chosen to produce them. Like seeding a Perlin Noise and somehow getting the impression of scrawled 'letter' shapes saying "This was just the first death!! I shall kill again!!!!".as a result.

That said, I like what you're looking at. I assume you already knew about the likes of the Dragon Curve, BTW?

Re: a neat picture based on recursive number

Posted: Sat Feb 02, 2019 5:59 pm UTC
by FlatAssembler
Here is a picture I made in my own programming language a few days ago:

Code: Select all

;Mathematical example: The Polar Rose.
AsmStart
   format PE console
   entry start
   include 'win32a.inc'
   section '.text' code executable
   start:
   invoke system,_cls
   invoke system,_setGreenForeground
AsmEnd
y:=0
While y<24
   x:=0
   While x<80
      distance:=sqrt(pow(abs((x-40)/2),2)+pow(abs(y-12),2))
      angle:=atan2(y-12,(x-40)/2)
      r:=cos(angle*3)*12
      If (distance < (r + 0.5) ) | ( (y = 12) & (x > 40-1) & (x < 40 + (13 * 2) ) )
         AsmStart
            jmp starSign$
            starSign:
               db '*',0
            starSign$:
            sub esp,4
            mov dword [esp],starSign
            call [printf]
         AsmEnd
      Else
         AsmStart
            jmp spaceSign$
            spaceSign:
               db ' ',0
            spaceSign$:
            mov dword [esp],spaceSign
            call [printf]
         AsmEnd
      EndIf
      x:=x+1
   EndWhile
   AsmStart
      jmp newLineSign$
      newLineSign:
         db 10,0
      newLineSign$:
      sub esp,4
      mov dword [esp],newLineSign
      call [printf]
   AsmEnd
   y:=y+1
EndWhile
AsmStart
invoke system,_pause
invoke system,_restoreColors
invoke system,_cls
invoke exit,0
_cls db "CLS",0
_setGreenForeground db "COLOR 0A",0
_pause db "PAUSE",0
_restoreColors db "COLOR 07",0

section '.rdata' readable writable
result dd ?
x dd ?
y dd ?
distance dd ?
angle dd ?
r dd ?

section '.idata' data readable import
library msvcrt,'msvcrt.dll'
import msvcrt,printf,'printf',system,'system',exit,'exit',scanf,'scanf'

AsmEnd