Hilberta līkne

Hilberta līkne (zināma arī kā Hilberta telpu piepildošā līkne) ir nepārtraukta fraktāļu plakni piepildoša līkne, kuru pirmoreiz aprakstīja vācu matemātiķis Dāvids Hilberts 1891. gadā.

Tā kā tā ir plakni piepildoša, tās Hausdorfa dimensija (pie robežas ) ir .

Eiklīda attālums  ir , t.i. tas aug eksponenciāli ar .

Vairākdimensiju datubāzēs ir ietikts izmantot Hilberta kārtu z-kārtas līknes vietā tās labāko lokalitātes saglabāšanas īpašību dēļ. Databāzu algoritmi ar Hilberta kārtību tiek pielietoti

Attēlojums Lindemaijera sistēmā 
Lindemaijera sistēmā Hilberta līkni var izteikt kā pārrakstīšanas sistēmu. 

Alfabēts : L, R
Konstantes : F, +, −
Aksioma : L 
Produkciju likumi: 
 L → +RF−LFL−FR+ 
 R → −LF+RFR+FL−

Kur F nozīmē "zīmēt uz priekšu", + nozīmē "pagriezties par 90° pa kreisi" un - - "pagriezties par 90° pa labi" ( bruņurupuču grafika).

Datorprogramma 

A. R. Butzs  ir izveidojis algoritmu vairākdimensiju Hilberta līknes veidošanai. libHilbert ir C++ bibliotēka, kas izmanto Butza algoritmu vairākām dimensijām.

Šī Java sīklietotne zīmē Hilberta līkni, rekursīvi izsaucot četras metodes:
import java.awt.*;
import java.applet.*;

public class HilbertCurve extends Applet {
    private SimpleGraphics sg=null;
    private int dist0=512, dist=dist0;

    public void init() {
        dist0 = 512;
        resize ( dist0, dist0 );
        sg = new SimpleGraphics(getGraphics());
    }

    public void paint(Graphics g) {
        int level=4;
        dist=dist0;
        for (int i=level;i>0;i--) dist /= 2;
        sg.goToXY ( dist/2, dist/2 );
        HilbertA(level); // start recursion
    }

    private void HilbertA (int level) {
        if (level > 0) {
            HilbertB(level-1);    sg.lineRel(0,dist);
            HilbertA(level-1);    sg.lineRel(dist,0);
            HilbertA(level-1);    sg.lineRel(0,-dist);
            HilbertC(level-1);
        }
    }

    private void HilbertB (int level) {
        if (level > 0) {
            HilbertA(level-1);    sg.lineRel(dist,0);
            HilbertB(level-1);    sg.lineRel(0,dist);
            HilbertB(level-1);    sg.lineRel(-dist,0);
            HilbertD(level-1);
        }
    }

    private void HilbertC (int level) {
        if (level > 0) {
            HilbertD(level-1);    sg.lineRel(-dist,0);
            HilbertC(level-1);    sg.lineRel(0,-dist);
            HilbertC(level-1);    sg.lineRel(dist,0);
            HilbertA(level-1);
        }
    }

    private void HilbertD (int level) {
        if (level > 0) {
            HilbertC(level-1);    sg.lineRel(0,-dist);
            HilbertD(level-1);    sg.lineRel(-dist,0);
            HilbertD(level-1);    sg.lineRel(0,dist);
            HilbertB(level-1);
        }
    }
}

class SimpleGraphics {
    private Graphics g = null;
    private int x = 0, y = 0;    

    public SimpleGraphics(Graphics g) { this.g = g; }
    public void goToXY(int x, int y) { this.x = x;   this.y = y; }

    public void lineRel(int deltaX, int deltaY) {
        g.drawLine ( x, y, x+deltaX, y+deltaY );
        x += deltaX;    y += deltaY;
    }
}

Vēl viena versija, kas realizē attēlojumu Lindenmaijera sistēmā. Kods rakstīts Tuga Turtle valodā. 
  def f
    walk 10
  end
  def p
    turn 90
  end
  def m
    turn -90
  end
  def l(n)
    return if n==0
    p; r(n-1); f; m; l(n-1); f; l(n-1); m; f; r(n-1); p
  end
  def r(n)
    return if n==0
    m; l(n-1); f; p; r(n-1); f; r(n-1); p; f; l(n-1); m
  end
  
  l(6)

Atsauces

Skatīt arī 
 Sierpinska līkne
 z-kārtība (līkne)

Fraktāļu līknes