Co-Rekursion

In der funktionalen Programmierung geht es bei Corecursion darum, die Schritte zu erstellen, indem die Ausgabe eines Schritts als Eingabe des nächsten Schritts verwendet wird, beginnend mit dem ersten Schritt. Es funktioniert synthetisch, ausgehend vom Basisfall. Es handelt sich um einen Bottom-up-Ansatz, der Daten aus einem Basisfall generiert. Es wird verwendet, um beliebig komplexe und unendliche Strukturen wie Ströme in einer Folge endlicher Schritte zu erzeugen. Es wird häufig bei verzögerter Auswertung verwendet, um einen endlichen Teil einer potenziell unendlichen Struktur zu generieren.

Rekursion

Rekursion ist etwas dasselbe wie Kernkursion. Der einzige Unterschied liegt in der Herangehensweise. Es zerlegt das Problem in einfachere Schritte, bis die einfachsten oder grundlegendsten Schritte erreicht sind (Basisfall). Es arbeitet analytisch, beginnt bei den Daten und wiederholt sich, bis es den Basisfall erreicht, was eher ein Top-Down- Ansatz ist, der die Aufgaben reduziert, wie es sich selbst nennt.

Teile der Rekursion.

1. Basisfall: Dies ist die Bedingung, die die rekursive Methode beendet. Dies ist der grundlegendste Schritt, der ohne den Einsatz weiterer rekursiver Aufrufe gelöst werden kann. Wenn diese Bedingung erfüllt ist, beginnt die rekursive Methode mit dem Abwickeln und gibt bei jeder abgewickelten Methode einen Wert zurück.
2. Rekursiver Schritt: Wird im Allgemeinen durch das Prinzip der mathematischen Induktion gebildet und definiert ein gegebenes Problem anhand eines kleineren Problems. Dabei wird dieselbe Funktion aufgerufen, jedoch mit einem reduzierten Eingabesatz.
3. Rückgabewert: Dies ist die Kombination der verschiedenen Ausgaben, die von Unterprogrammen erzeugt werden. Dabei handelt es sich im Wesentlichen um die Aggregation oder Berechnung einiger Daten basierend auf den Ergebnissen der rekursiven Aufrufe.

Dies ist die grundlegende Syntax für jede rekursive Methode.

<access-specifier> <modifier> <return-type> methodName(formal-arguments-list) {
 if(base condition)
  return something..
 return methodName(simpler-formal-arguments-list);
}

public int fibonacciSeries(int n) {
 if(n <= 1)
  return 1;
 return fibonacciSeries(n-1) + fibonacciSeries(n-2);
}

Fraktale Bäume sind eine Art Muster, das Selbstähnlichkeit aufweist, was bedeutet, dass sie dieselbe Form oder dasselbe Muster in verschiedenen Maßstäben wiederholen. Es gibt mehrere Algorithmen, die Ihnen bei der Generierung fraktaler Bäume helfen können, aber wie üblich ist der rekursive Ansatz der einfachste von allen.

Die Rekursion minimiert den Aufwand, immer mehr Variablen zu definieren, und vermeidet die Erstellung eines Spaghetti-Codes.

Fraktale Bäume haben in der realen Technologie viele Anwendungen. Sie können verwendet werden, um in Spielen mehrere reale Objekte wie Korallenriffe zu modellieren und visuell erstaunliche Muster und Designs zu erstellen.

Was benötigen Sie, um weiter vorzugehen?

Es gibt einige Voraussetzungen, um mit diesem Beitrag fortzufahren. Es beinhaltet Grundkenntnisse der Grafikentwicklung in Java. Da dieser Beitrag einen klaren visuellen Einblick in Fraktalbäume bieten soll, wird im Folgenden ein Fraktalbaum in einer Grafikumgebung dargestellt. Daher wäre es hilfreich, wenn man eine gewisse Vorstellung von der Grafikprogrammierung hat.

Es geht los..

Lassen Sie uns einen Algorithmus zum Erstellen eines Fraktalbaums verstehen und mit dem Schreiben beginnen.

Algorithmus

1. Definieren Sie eine Methode drawFractalTree(int, int, int , int) , die die Startkoordinaten (x, y) eines Zweigs, den Winkel zwischen den Zweigen in Bezug auf die Vertikale und die Höhe der fraktalen Baumhöhe annimmt .
2. Basisfall: Wir sollten verstehen, dass wir nicht mit dem Zeichnen eines weiteren Zweigs fortfahren dürfen , wenn ein Benutzer die Höhe des Baums als 0 angibt. Und daher wird dies zum Basisfall unseres Programms. Hier enden unsere rekursiven Aufrufe.
3. Berechnen Sie die nächsten Koordinaten des fraktalen Baumzweigs mithilfe vordefinierter mathematischer Funktionen unter Angabe des Winkels im Bogenmaß.

y-Koordinate = sin(angleRad) * Höhe * Tiefe

4. Dies ist die einzige Möglichkeit, die anderen beiden Koordinaten des fraktalen Zweigs zu generieren. Bei zwei x-Koordinaten und zwei y-Koordinaten können wir die beiden Punkte mit der Funktion drawLine(int, int, int, int) der Graphics- Klasse verbinden.

5. Jetzt rufen wir die Methode drawFractalTree erneut auf, allerdings mit etwas geändertem Winkel und reduzierter Höhe.

Programm.

Jede Erklärung eines Programmierproblems ist nichts ohne den Pseudocode. So implementieren Sie die Methode drawFractalTree .

void drawFractalTree( x, y, angle, height) :
 if height == 0
  return
 
 x2 = cos( toRadians(angle) ) * height * depth
 y2 = sin( toRadians(angle) ) * height * depth
 
 drawLine(x, y, x2, y2)

 drawFractalTree(x2, y2, angle - 10, height - 1)

1. Erstellen der Treiberklasse: Dadurch wird die Anwendung durch Aufrufen der Ausführungsmethode in der Anwendungsklasse gestartet .

package com.projectjava;

public class Main {
 public static void main(String[] args) {
  Application.run(args);
 }
}

package com.projectjava;

import java.swing.JFrame;

public class Application extends JFrame {
 ...
}

public static void run(String[] args) {
 var app = new Application();
 app.setSize(700, 700);
 app.setVisible(true);
 app.setTitle("Fractal Trees");
}

public Application() {
  this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  this.setResizable(false);
}

@Override
public void paint(Graphics g) {
 drawFractalTree(250, 650, -90, 10);
}

public void drawFractalTree(int x, int y, int angle, int height, Graphics g) {
 if (height == 0)
  return;
 
 int x2 = (int)Math.cos(Math.toRadians(angle)) * height * 10;
 int y2 = (int)Math.sin(Math.toRadians(angle)) * height * 10;
 g.setColor(Color.WHITE);
 g.drawLine(x, y, x2, y2);

 drawFractalTree(x2, y2, angle-20, height-1);
 drawFractalTree(x2, y2, angle+20, height-1);

}

if(height == 0) {
 g.setColor(Color.RED);
 g.fillOval(x-2, y, 5, 5);
}

https://youtu.be/R0ePX8UO52w

Das ist alles für diesen Beitrag, danke, dass Sie ihn gelesen haben. Ich hoffe, Sie haben die Anwendungen der Rekursion verstanden. Danke!!