DEV Community: Max Kleiner

The Open Railway Map API

Max Kleiner — Mon, 03 Nov 2025 17:33:28 +0000

The OpenRailwayMap (ORM) is an OpenStreetMap-based project designed to create a detailed map of the world’s railway infrastructure. It provides a variety of tools, APIs, and map styles to visualize railway data, including tracks, stations, signals, and speed limits.

Key Features and Usage

The OpenRailwayMap database is built on OpenStreetMap data and is available under the Open Database License (ODbL). The rendered map tiles are distri-buted under the CC-BY-SA 2.0 license. The project is non-commercial and main-tained by volunteers, relying on donations for its operation.

The database supports querying railway-related information through a RESTful API. This API allows users to search for stations by name or reference code and retrieve mileage data for specific railway lines. The API documentation is hosted on GitHub.

Map Styles and Tile Access

The map tiles are rendered in Web Mercator projection and are available in different styles, such as:

Standard: Displays railway infrastructure like tracks, stations, and switches.
Signals: Visualizes railway signals and train protection systems.
Maxspeed: Shows maximum speeds and speed signals for railway lines. Tiles can be accessed via URLs in the format:

http://${s}.tiles.openrailwaymap.org/${style}/${z}/${x}/${y}.png

Here, ${s} can be replaced with subdomains (a, b, or c) for faster loading, and ${style} specifies the map style.

Integration with Tools

The OpenRailwayMap tiles can be integrated into various mapping libraries and tools:

OpenLayers and Leaflet: Easily add OpenRailwayMap layers using their respective APIs.
OsmAnd: Overlay OpenRailwayMap tiles on offline maps with the “Online maps” plugin.
QGIS: Load OpenRailwayMap tiles as XYZ layers for GIS analysis. The OpenRailwayMap API and tiles are free for non-commercial, small-scale applications. Commercial use requires setting up a private server. Bulk requests and misuse of headers (e.g., faking user-agent) are prohibited. Applications must include proper attribution when using the tiles or API. For example we search for Kamakura Station, Japan:

OpenRailwayMap

https://www.openrailwaymap.org/?style=standard&lang=en&lat=35.319152192198985&lon=139.5503568649292&zoom=14

The project operates without guarantees of availability or support. Users requiring high reliability are encouraged to deploy their own instances of the API or image tile server.

For further details, visit the OpenRailwayMap GitHub repository or the OpenStreetMap Wiki page.

https://wiki.openstreetmap.org/wiki/OpenRailwayMap/API

So first we call the REST-API to get a stations facility information in JSON:

const URL_ORM_GET9 = 
   'https://api.openrailwaymap.org/v2/facility?name=%s&limit=1';

function API_GEOLocation_ORM9(AURL, aloc, aApikey: string;
                                             verbose: boolean): Tlatlong;
var Httpreq: THttpRequestC; httpres: string; jsn: TMcJsonItem;
begin
  httpreq:= THttpRequestC.create(self);
  httpreq.headers.add('Accept: application/json; charset=utf-8');
  //httpreq.headers.add('X-Api-Key:'+aAPIkey);
  httpreq.useragent:= USERAGENT5;
  httpreq.SecurityOptions:= [soSsl3,soPct,soIgnoreCertCNInvalid];
  try
    if httpreq.get(Format(AURL,[aloc])) then begin
       httpres:= (httpreq.Response.ContentAsUTF8String)
       writeln('conttype '+httpreq.Response.ContentType);
       if verbose then writ('debug back '+formatJson(httpres));
       jsn:= TMcJsonItem.Create;
       jsn.AsJSON:= httpres;
       writ('debug name: '+jsn.at(0,'name').asstring)
       writ('debug operator: '+jsn.at(0,'operator').asstring)
       result.lat:= jsn.at(0,'latitude').asnumber;  
  //in the api now fixed
       result.long:= jsn.at(0,'longitude').asnumber;

       result.descript:= Format('Coords: lat %2.5f lng %2.5f %s
        osm_id: %s operator: %s',
                  [result.lat,result.long,jsn.at(0,'name').asstring,
                                        jsn.at(0,'osm_id').asstring,
                                        jsn.at(0,'operator').asstring]); 

    end else Writeln('APIError '+inttostr(Httpreq.Response.StatusCode2));
  except 
    writeln('EWI_APIHTTP:
                 '+ExceptiontoString(exceptiontype,exceptionparam));  
  finally 
    writeln('Status3: '+gethttpcod(httpreq.Response.statuscode2))
    httpreq.Free;  
    sleep(200);
    jsn.Free;
  end; 
end;

The API returns JSON formatted data with following fields:

latitude: latitude, longitude: longitude
osm_id: OSM node ID
rank: an importance rank calculated by taking the public transport route relations into account using this station/halt. All OSM tags present on this object. The following tags are very often in use. See the OSM wiki and Taginfo for a more comprehensive list of possible tags.
name: name, uic_name: UIC station name
railway:ref: reference assigned by the operator of the infrastructure
railway: type of the facility following Tagging rules), e.g. station, halt, junction, yard.
operator: operator of the infrastructure

Open Railway Map:________________________________________________
conttype application/json
debug back [{
“osm_id”: 506122717,
“name”: “鎌倉”,
“railway”: “station”,
“ref”: null, “train”: “yes”,
“name:en”: “Kamakura”,
“name:es”: “Kamakura JR”,
“name:it”: “Kamakura”,
“name:ja”: “鎌倉”,
“name:ko”: “가마쿠라”,
“name:zh”: “镰仓”,
“operator”: “東日本旅客鉄道”,
“wikidata”: “Q932895”,
“wikipedia”: “ja:鎌倉駅”,
“name:ja-Hira”: “かまくら”,
“name:ja-Latn”: “Kamakura”,
“public_transport”: “station”,
“latitude”: 35.31911869967492,
“longitude”: 139.5504286,
“rank”: 12
}]
debug name: \u938c\u5009
debug operator: \u6771\u65e5\u672c\u65c5\u5ba2\u9244\u9053
Status3: SC_OK Coords: lat 35.31912 lng 139.55043 鎌倉 osm_id: 506122717 operator: 東日本旅客鉄道

mX5🐞 executed: 02/11/2025 08:48:43 Runtime: 0:4.305 Memload: 64% use

MP3 Stream Shell

Max Kleiner — Thu, 24 Jul 2025 16:05:03 +0000

We found a solution with Github as a media server. Our URL to MP3 converter stream server serves as an open source for online song downloading or streaming. You can copy the URL of the song you want to download, or paste it to our online MP3 converter website or play it direct as an URL stream in the following script:!

SongURL5 = 'https://raw.githubusercontent.com/maxkleiner/maXbox5/main/assets/Sternenhaufen_Max_SunoAI.mp3';
Tutor152 =
https://github.com/maxkleiner/maXbox5/blob/main/examples/maxbox_starter152_MP3_Sound_Engine.pdf
//'http://www.softwareschule.ch/download/maxbox_starter152.pdf';

var mp3Stream: TMemoryStream;
    mp3Stream:= TMemoryStream.create;
    Http_GetStream(SongURL5, mp3Stream);
    PlayMp3FromStream(mp3stream);
    mp3stream.free;  //}

A raw GitHub link allows you to access the raw content of a file stored in a GitHub repository. This can be useful for directly accessing files such as images, songs, text files, or scripts without the GitHub interface. We use this also to execute a JavaScript link to run in a local embedding browser in maXbox.

The ComObject CreateOleObject('WMPlayer.OCX') control gives you direct control of media, including reading and writing to the files or metadata/tags.
Additionally, some automation interfaces are implemented by automation objects, and the properties and methods of those interfaces are inherited by the objects like wmp.controls.play.

procedure PlaySurprise_MP3_Media2;
var wmp: Variant; 
 //Maybe you'll be more comfortable with automation.
 //I believe it would provide most of functionality as interfaces provide.
begin
   wmp:= CreateOleObject('WMPlayer.OCX');
   if ISInternetconnected then begin
     wmp.URL:= SongURL5;
     wmp.OpenPlayer(wmp.URL);
   end else  //}
     wmp.OpenPlayer(Exepath+'examples\Sternenhaufen_Max_SunoAI.mp3');
  //wmp.controls.play;
end;

Lychrel number

Max Kleiner — Thu, 24 Apr 2025 18:42:03 +0000

A Lychrel number is a natural number that cannot form a palindrome through the iterative process of reversing its digits and adding the resulting numbers. This process is often referred to as the 196-algorithm, named after the most famous number associated with it.
To determine if a number is a Lychrel number in Pascal, we implement a string-based approach to handle large numbers generated during iterations. Here's a structured solution:

Key Components

String Reversal: Reverse the digits of a number represented as a string.
String Addition: Add two large numbers (as strings) to avoid integer overflow.
Palindrome Check: Verify if a string is a palindrome.
Iteration Loop: Perform up to 500 iterations of reversal and addition, checking for palindromes.

Pascal Implementation

var
  Seeds : array of LongInt;

function ReverseString(s: string): string;
var i: integer;
begin
  Result:= '';
  for i:= Length(s) downto 1 do
    Result:= Result + s[i];
end;

function AddStrings(a, b: string): string;
var i, sum, carry: integer;
begin
  carry:= 0;
  Result:= '';
  while Length(a) < Length(b) do a:= '0' + a;
  while Length(b) < Length(a) do b:= '0' + b;
  for i:= Length(a) downto 1 do begin
    sum:= (Ord(a[i])- Ord('0'))+ (Ord(b[i])- Ord('0'))+ carry;
    carry:= sum div 10;
    Result:= inttoAscii((sum mod 10)+ Ord('0'),1)+ Result;
  end;
  if carry > 0 then Result:= inttoascii(carry + Ord('0'),1)+ Result;
  while (Length(Result) > 1) and (Result[1] = '0') do Delete(Result,1,1);
end;

function IsPalindrome(s: string): boolean;
var i: integer;
begin
  for i:= 1 to Length(s) div 2 do
    if s[i] <> s[Length(s)-i+1] then begin result:= false Exit; end;
  Result:= True;
end;


//correctly identifies Lychrel numbers like 196 as bool
var lfound: string;
function IsLychrel(n: Integer; maxIterations: Integer): Boolean;
var numStr, reversedStr: string;
    i: integer;
begin
  numStr:= IntToStr(n);
  processmessagesOFF;
  for i:= 1 to maxIterations do begin
    reversedStr:= ReverseString(numStr);
    numStr:= AddStrings(numStr, reversedStr);
    writeln(itoa(i)+':'+numstr)
    if IsPalindrome(numStr) then begin write(numstr+' steps: '+itoa(i)); 
                              lfound:= numstr; result:= false Exit; 
                            end;
  end;
  processmessagesON;
  Result:= True;
end;

Explanation

String Handling: Numbers are processed as strings to manage arbitrarily large values!
Reversal and Addition: Each iteration reverses the current number and adds it to the original, ensuring correct handling of leading zeros.
Palindrome Check: Compares the string to its reverse after each addition.
Efficiency: The algorithm stops early if a palindrome is detected or after 500 iterations, whichever comes first.

This approach correctly identifies Lychrel numbers like 196, which do not form palindromes within the iteration limit.

// Example usage
const maxIter = 500;
//number= 196;  as proof for never finding!
var number: integer;

  number:= 294;        //196  is! 295
  if IsLychrel(number, maxIter) then
    Writeln(itoa(number)+' is a Lychrel number.')
  else
    Writeln(itoa(number)+' is not a Lychrel number, cause we found: '+lfound);

1:786
2:1473
3:5214
4:9339
9339 steps: 4
294 is not a Lychrel number, cause we found: 9339
mX5🐞 executed: 24/04/2025 20:38:19 Runtime: 0:0:2.242 Memload: 75% use

294 explained in 4 steps:

294+492=786
786+687=1473
1473+3741=5214
5214+4125=9339!

The script can be found at:
1398_Lychrel_numbers12_uc.txt

Geocoding Distance🐞

Max Kleiner — Wed, 23 Apr 2025 18:09:42 +0000

maXbox Starter 142 – Get a GEO distance.

“Natura abhorret vacuum1 – Spinoza.

Source: 1390_Sphenic_Numbers2TIO_12_py_uc.txt
1397_Geolocation_distance12_uc.txt

Nominatim can power the search box on your website, allowing your users to type free-form queries (“Cafe Paris, Cologne”) in any language. It also offers a structured query mode (“postcode=12345”, “city=London”, “type=cafe”) that helps you to automate geocoding of extensive address lists.

https://sourceforge.net/projects/maxbox5/files/examples/1274_GoogleMapsAPI_General1.pas/download

Sometimes life is like playing with us: You write some useful code that solves a problem, and then someone comes along and makes the problem much harder. Here’s how to continuously integrate new solutions without having to rewrite your old solutions (as much). Means you don’t have to change the language, you change the environment.

Let’s start with a simple problem: Get the distance between two earth-coordinates. Calculating the geographical distance between two points on the Earth’s surface can be done using the Haversine formula. This formula accounts for the spherical shape of the Earth. Below is a Delphi and Python function that performs this calculation:

type
 TipGeolocation = record
     Latitude: Double; //read Coordinates[0] write SetLatitude;
     Longitude: Double; //read Coordinates[1] write SetLongitude;
  end;

For the purposes of this task we make the problem harder, a geocoding function with a record pair of coordinates:

const
    EARTHS_RADIUS_IN_METERS = 6378137;  


function TipGeolocationDistanceInMetersTo(
                     const AGeolocation: TipGeolocation;
                           Latitude, Longitude: Double): Double;
var LDeltaLat, LDeltaLong, LA: Double;
begin
  LDeltaLat:= DegToRad(AGeolocation.Latitude - Latitude);
  LDeltaLong:= DegToRad(AGeolocation.Longitude - Longitude);
  LA:= Sin(LDeltaLat / 2) * Sin(LDeltaLat / 2) + Cos(DegToRad(Latitude)) * 
       Cos(DegToRad(AGeolocation.Latitude)) * Sin(LDeltaLong / 2) * Sin(LDeltaLong / 2);
  Result:= Abs(EARTHS_RADIUS_IN_METERS * 2 * ArcTan2(Sqrt(LA), Sqrt(1 - LA)));
end;

This function calculates the distance between two points given their latitude and longitude in degrees. The example usage calculates the distance between Bern and Paris. Feel free to adapt the coordinates to your specific needs!

Geoloc_setup;    //reference data2
writeln('Distance Bern,CH - Paris,F: '+
         format('%2.4f m ',[TipGeolocationDistanceInMetersTo(tipgeoloc1,lat2,lon2)]));

And in Python: import math

def haversine_distance(lat1, lon1, lat2, lon2):
    # Radius of the Earth in kilometers
    R = 6371.0
    # Convert latitude and longitude from degrees to radians
    lat1_rad = math.radians(lat1)
    lon1_rad = math.radians(lon1)
    lat2_rad = math.radians(lat2)
    lon2_rad = math.radians(lon2)

    # Differences in coordinates
    dlat = lat2_rad - lat1_rad
    dlon = lon2_rad - lon1_rad

    # Haversine formula
    a = math.sin(dlat/2)**2+math.cos(lat1_rad)*math.cos(lat2_rad)*math.sin(dlon/2)**2
    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))

    # Distance in kilometers
    distance = R * c
    return distance

# Example usage
lat1 = 46.94809  # Latitude of Bern
lon1 = 7.44744   # Longitude of Bern
lat2 = 48.8566   # Latitude of Paris
lon2 = 2.3522    # Longitude of Paris

distance = haversine_distance(lat1, lon1, lat2, lon2)
print(f"The distance between Bern and Paris is {distance:.2f} kilometers.")

The distance between Bern and Paris is 434.96 kilometers.

Often, we calculate the great-circle distance of given two points in geophysics, for example, the distance from the seismic station to the epicenter.
Supposing that we have two geographical points, and let’s say P1:(ϕ1,λ1) and P2:(ϕ2,λ2), where,ϕ and λ represent the latitude and longitude, respectively. Using **Haversine **formula, we can calculate the great-circle distance.

The great-circle distance, orthodromic distance, or spherical distance is the distance between two points on a sphere, measured along the great-circle arc between them.

Paris Place Madeleine Place de la Madeleine

Next we need a geocoding API. Geocoding is the process of transformation of any location name into geographical coordinates, and the other way around (reverse geocoding). OpenWeather’s Geocoding API and OpenStreetMap supports both the direct and reverse methods, working at the level of city names, areas and districts, countries and states:

https://nominatim.openstreetmap.org/search?format=json&q=madeleine,paris
Test the link above then you get:

Its not a unique place, different results as JSON possible
Take the result with the most importance after place_rank like 0.50962:

const URL_GEOLOCURL9 = 'https://nominatim.openstreetmap.org/search?format=json&q=%s';
      URL_APILAY_GEO = 'https://api.apilayer.com/geo/country/capital/%s';  

var fromgeo, togeo: Tlatlong;      

function API_GEOLocation_OSM9(AURL, aloc, aApikey: string;
                                             verbose: boolean): Tlatlong;
var Httpreq: THttpRequestC; httpres: string;
    jsn: TMcJsonItem;
begin
  httpreq:= THttpRequestC.create(self);
  httpreq.headers.add('Accept: application/json; charset=utf-8');
  //httpreq.headers.add('X-Api-Key:'+aAPIkey);
  httpreq.useragent:= USERAGENT5;
  httpreq.SecurityOptions:= [soSsl3, soPct, soIgnoreCertCNInvalid];
  try
    if httpreq.get(Format(AURL,[aloc])) then begin
       httpres:= (httpreq.Response.ContentAsUTF8String)
       writeln('conttype '+httpreq.Response.ContentType);
       if verbose then writ('debug back '+formatJson(httpres));
       jsn:= TMcJsonItem.Create;
       jsn.AsJSON:= httpres;
       result.lat:= jsn.at(0,'lat').asnumber;
       result.long:= jsn.at(0,'lon').asnumber;
       result.descript:= Format('Coords: lat %2.5f lng %2.5f %s osm_id: %s ',
                                [result.lat,result.long,jsn.at(0,'name').asstring,
                                                        jsn.at(0,'osm_id').asstring]); 
    end else Writeln('APIError '+inttostr(Httpreq.Response.StatusCode2));
  except
    writeln('EWI_APIHTTP: '+ExceptiontoString(exceptiontype,exceptionparam));  
  finally
    writeln('Status3: '+gethttpcod(httpreq.Response.statuscode2))
    httpreq.Free;  
    sleep(200);
    jsn.Free;
  end; 
end;
const

URL_GEOLOCURL9 = ‘https://nominatim.openstreetmap.org/search?format=json&q=%s‘;

URL_APILAY_GEO = ‘https://api.apilayer.com/geo/country/capital/%s‘;

Test it by calling the const URL below, for example:

https://nominatim.openstreetmap.org/search?format=json&q=paris
https://softwareschule.code.blog/wp-content/uploads/2025/04/image-4.png?w=1024

Nominatim uses OpenStreetMap data to find locations on Earth by name and address (geocoding) as you can see in the const URL_GEOLOCURL9. It can also do the reverse, find an address for any location on the planet. The Geocoding API relies on a redundant infrastructure of own geocoder nodes powered by the Nominatim software with edge servers for fast delivery of results.
Note that when you get an

APIError 403
Status3: SC_FORBIDDEN
Status3: SC_FORBIDDEN
Exception: Invalid pointer operation at 875.1746

or an

EWI_HTTP: Exception: The request has timed out.
Status3:
Null Pointer Exception at 929.1876

then you are not following the Nominatim Usage policy, see here: https://operations.osmfoundation.org/policies/nominatim/

You’ll have to be esp. careful about including a unique user agent for your application and change from time to time;

It sounds like you’re encountering a “403 Forbidden” error when trying to use the Nominatim API. This error typically indicates that your request is being blocked, possibly due to rate limiting, incorrect usage, or IP blocking. Here are a few steps you can take to troubleshoot and resolve this issue:

Check API Usage Limits: Ensure that you are not exceeding the usage limits set by Nominatim. They have strict policies to prevent abuse. Review their usage policy to make sure you’re compliant.

User-Agent Header: Nominatim requires a valid User-Agent header in your requests. Make sure you include a descriptive User-Agent string that identifies your application. Best is do rotate useragents:

const
  USERAGENT5 = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like
                                                                              Gecko)'+
                   ' Chrome/126.0.0.0 Safari/537.36 Edg/126.0.0.0 '; 
  USERAGENT2 = 'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1';  
  USERAGENT3 = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like
                Gecko)'+' Chrome/125.0.0.0 Safari/537.3';                // chrome + win   
  USERAGENT4 = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15'+
                   ' (KHTML, like Gecko) Version/17.4.1 Safari/605.1.1'; // safari + mac
  USERAGENT1 = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 '+    
                   '(KHTML, like Gecko) Chrome/126.0.0.0 Edg/126.0.0.';  // edge + win
const useragents

softwareschule.ch/examples/geodistance1.htm

Most of the time, ~ 75% in this case, it is spent with API IP-connection. So we put in maXbox processmessagesOFF; and processmessagesON; between start and stop-time for time measure.

The interesting point is to know where the code is running and how it is stored in an executable or script itself. Solution 1 and 2 can running on the web or on premise all others run locally or on a server.

3 Solutions Overview of GEO Distance Math Solver

The multiplication of past x future is a vector with the function:= known = f(changeable) [y=f(x)] as distance over time.
The vector is a timeline as a vector space of {t,d}(time,distance) so distance is a function of time: d=f(t)

As changeable = f(states) it says the more states we have the more knowledge as known() is possible,
So a substitution: known = f(f(states))
legend: y(unknown -> known)[d:distance]
x(unchangeable -> changeable)[t:time]
variant:x(immutable -> mutable)[t:time]

Past = [unchangeable,known]

Future = [changeable,unknown]

Present= [changeable,known],[t->0]

BigBang= [unchangeable,unknown],[d->∞]

Conclusion

When it comes to problem-solving, there are often multiple solutions that can be used to solve the same problem. The choice of solution depends on various factors such as performance, storage, implementation, simplicity, and also scaleability and security in different environments. The code is more or less the same but the choice of the environment (script, executable, container, hosting, web or cloud API) could be a response of different requirements.

Great Circle Mapper is a tool that shows the shortest route between two or more locations on a globe. You can enter airports, cities, or coordinates and get a distance back with a geocode API.

Script:

https://sourceforge.net/projects/maxbox5/files/examples/1397_Geolocation_distance12_uc.txt/download

References:
Home – Geocoding API Documentation

Doc and Tool: maXbox5 – Manage Files at SourceForge.net

As PDF: http://www.softwareschule.ch/download/maxbox_starter142.pdf

Max Kleiner 23/04/2025

1 Nature recoils from emptiness –

Garmin GPS Distance Tracking

TGV Inoui 543-550-540 Paris Gare d’Est Ostern 2025

Multi Pascal Solver

Max Kleiner — Wed, 09 Apr 2025 10:01:24 +0000

“Natura abhorret vacuum” 1 — Spinoza.

Source: 1390_Sphenic_Numbers2TIO_12_py_uc.txt

Let’s start with a simple problem: For a new kind of two-factor authentication security you have to find the first 1000 sphenic numbers. A sphenic number is a positive integer that is the product of three distinct prime numbers. More technically it’s a square-free 3-almost prime (see Related tasks below).

For the purposes of this task, a sphenic triplet is a group of three sphenic numbers which are consecutive.

I want to show the solution from rosettacode in five language variants:

Pascal
Python
Free Pascal
Free Pascal TIO Web
Delphi

Note that sphenic quadruplets are not possible because every fourth consecutive positive integer is divisible by 4 (= 2 x 2) and its prime factors would not therefore be distinct. Example

30 (= 2 x 3 x 5) is a sphenic number and is also clearly the first one. Lets start with Object Pascal in maXbox5 Editor:

Result in maXbox Console

procedure CreateSphenics(const pr: TInt64Array{tarrElements});
var
  i1,i2,i3,
  idx1,idx2,
  p1,p2,pp,cnt : Uint32;
begin
  cnt:= 0;
  pp:= trunc(exp(1/3*ln(LLimit)));
  idx1:= binary_search(pp,Pr)-1;
  i1:= 0;
  writeln('last prime: '+itoa(pr[high(pr)])+' of primes: '+itoa(high(pr)));
  repeat
    p1 := pr[i1];
    pp:= trunc(sqrt(LLimit DIV p1));
    idx2:= binary_search(pp,Pr)+1;
    For i2:= i1+1 to idx2 do begin
      p2:= pr[i2]*p1;
      For i3:= i2+1 to High(pr) do begin
        pp:= Pr[i3]*p2;
        if pp > LLimit then
          break;
        //mark as sphenic number
        PrimeSieve[pp]:= true;    //todo -done
        //primes[pp]:= 1;
        inc(cnt);
      end;
    end;
    inc(i1);
  until i1>idx1;
  //insert
  setlength(sphenics,cnt);
  pp:= 0;
  For i1:= 0 to LLimit do begin
    if primeSieve[i1] then begin
      sphenics[pp]:= i1;
      inc(pp);
    end; 
  end;
  //primeSieve.Free;
end;

Most of the time, ~ 75% in this case, is spent with sort. So i put in maXbox processmessagesOFF; and processmessagesON; between binary search to speed up and Now changed to use sieve of erathostenes and insert sphenic numbers in that array, as you can see dynamic arrays are the main storage:

const
  LLimit= 1000*1000;  // *1000;

type
  tPrimesSieve = array of boolean;
  ttElement = Uint32;
  tarrElements = array of ttElement;

var
  PrimeSieve : tPrimesSieve;
  primes : TInt64Array; // object prefilled //tarrElements;
  sphenics : tarrElements;

We also use a class TPrimes for the primes array sieve, so its also Object Pascal:

try
  ClearAll;
  Sieve:=TPrimes.Create;
  primes:= sieve.prime;
  setlength(primes,78500);
  setlength(PrimeSieve,LLimit+1);// inits with #0
  CreateSphenics(Primes);   //must be the filled primes
finally
  Sieve.Free;
end;

Sphenic Numbers

Next will be the Python one as Python4Delphi in maXbox5:

""" rosettacode.org task Sphenic_numbers """
//https://rosettacode.org/wiki/Sphenic_numbers#Python

from sympy import factorint

sphenics1m, sphenic_triplets1m = [], []

for i in range(3, 1_000_000):
    d = factorint(i)
    if len(d) == 3 and sum(d.values()) == 3:
        sphenics1m.append(i)
        if len(sphenics1m) > 2 and i - sphenics1m[-3] == 2 and i - sphenics1m[-2] == 1:
            sphenic_triplets1m.append(i)

print('Sphenic numbers less than 1000:')
for i, n in enumerate(sphenics1m):
    if n < 1000:
        print(f'{n : 5}', end='\n' if (i + 1) % 15 == 0 else '')
    else:
        break

print('\n\nSphenic triplets less than 10_000:')
for i, n in enumerate(sphenic_triplets1m):
    if n < 10_000:
        print(f'({n - 2} {n - 1} {n})', end='\n' if (i + 1) % 3 == 0 else '  ')
    else:
        break

print('\nThere are', len(sphenics1m), 'sphenic numbers and', len(sphenic_triplets1m),
      'sphenic triplets less than 1 million.')

S2HK = sphenics1m[200_000 - 1]
T5K = sphenic_triplets1m[5000 - 1]
print(f'The 200_000th sphenic number is {S2HK}, with prime factors {list(factorint(S2HK).keys())}.')
print(f'The 5000th sphenic triplet is ({T5K - 2} {T5K - 1} {T5K}).')

And it will be of course the same result and interesting almost the same performance (~12 seconds):

There are 206964 sphenic numbers and 5457 sphenic triplets less than 1 million.
The 200_000th sphenic number is 966467, with prime factors [17, 139, 409].
The 5000th sphenic triplet is (918005 918006 918007).
mX5🐞 executed: 03/04/2025 10:04:44 Runtime: 0:0:13.64 Memload: 75% use

In Python4Delphi we import extra libaries with execstr:

procedure Delphi9_PySolution(loc: string);
var Data1, Data2 : array of Double; 
begin
  with TPythonEngine.Create(Nil) do begin
   //pythonhome:= PYHOME64;
   // -V:3.12 *   Python 3.12 (64-bit)
   loadDLL;
   autofinalize:= false;
   try
    execstr('import io, sys  # Added')
    execstr('output = io.StringIO()') 
    execstr('sys.stdout = output');  
    execstr('from sympy import factorint');
    execstr('sphenics1m, sphenic_triplets1m = [], []');

Next is a solution of the web therefore it runs in a browser:

Call of tio.run from maXbox5 generator to invoke the Free Pascal Compiler:

The web server of Try It Online and the arenas (where user code is executed) are currently run on three separate servers. TIO is getting more and more traffic, so additional arenas will be required. Also, server-side permalinks will eventually require a separate storage. With your help, I hope to ensure a smooth operation of all TIO services.

TIO is powered by DigitalOcean. Their virtual private servers are affordable, fast, scalable, and (most importantly) professionally managed. The TIO web app is free of charge, ad-free, and doesn’t use tracking cookies or third-party analytic scripts.

https://tio.run/#
The last solution is the Delphi one, not finished yet with further tests and profiling. The TPrimes class introduced has been enhanced to include the GetPrevPrime and GetNthPrime function and moved into a MathsLib unit which is included here with the source code zip file and is also now included in our common library file DFFLIBV04. The array of int64 will be filled with 78499 primes up to the last one 1,000,003 as the range of one million. There are exactly 78,498 prime numbers between 1 and 1,000,000. This count has been determined using mathematical methods such as the Prime Number Theorem, which estimates the density of primes below a given number.

In maXbox the class and library is precompiled so you dont need to install or import it.

Sieve:= TPrimes.Create;
  prime:= sieve.prime;
  writeln(itoa(prime[78499])+'  '+itoa(high(prime)));
  for it:=1 to 50 {Sieve.MaxPrimeInTable-1} do
     //write(itoa(Sieve.GetNthPrime(It))+' ');
     write(itoa(prime[It])+' ');
  sieve.free;
  GetSphenicNumbers(Sphenic);
  Memo2.Lines.Add('Some Sphenic numbers less than 1,000:');
  S:='';
  for i:=0 to 1000-1 {High(Sphenic)} do begin
     if Sphenic[i]>993 then break;
     S:=S+Format('%4d',[Sphenic[i]]);
     if (i mod 15)=14 then S:=S+CRLF;
   end;
  writeln(S); 
  writeln('Total Sphenic Numbers found = '+
      FloatToStrF(Sphenic[Length(Sphenic)-1]-800,ffNumber,18,0));

In number theory, a sphenic number (from Greek: σφήνα, ‘wedge’) is a positive integer that is the product of three distinct prime numbers. Because there are infinitely many prime numbers, there are also infinitely many sphenic numbers. The cyclotomic polynomials Φn(x){\displaystyle \Phi _{n}(x)}, taken over all sphenic numbers n, may contain arbitrarily large coefficients1.

Any multiple of a sphenic number (except by 1) is not sphenic. This is easily provable by the multiplication process at a minimum adding another prime factor, or raising an existing factor to a higher power.

Solutions Overview of Math Solver

1 Internal Pascal code scripting in maXbox5
2 External call of Python for Delphi (P4D)
3 Internal Free Pascal Compiler & Lazarus API
4 External call of Free Pascal TIO Web
5 Internal script (precompiled Delphi VM)

Conclusion

When it comes to problem-solving, there are often multiple solutions that can be used to solve the same problem. The choice of solution depends on various factors such as performance, storage, correctness, implement-ation, accessibility, simplicity, and also scaleability and security in different environments. The code is more or less the same but the choice of the environment (script, executable, container, hosting, web or cloud API) could be a response of different requirements.

The Script you can find at: https://sourceforge.net/projects/maxbox5/files/examples/1390_Sphenic_Numbers2TIO_12_py_uc.txt/download

https://rosettacode.org/wiki/Sphenic_numbers#Delph

Data Correlation Analysis

Max Kleiner — Sun, 09 Mar 2025 18:51:32 +0000

This tutorial on data analysis with Python and Python4Delphi, uses four powerful libraries: Pandas, Scikit (sklearn), Seaborn and Matplotlib.

The second part will put a spot concerning overfitting a model. This short section shows how the see overfitting with high variance measure.

Regarding the difference sklearn vs. scikit-learn: The package “scikit-learn” is recommended to be installed using pip install scikit-learn but in your code imported using import sklearn. A bit confusing, because you can also do pip install sklearn and will end up with the same scikit-learn package installed, because there is a small "dummy" pypi package sklearn which will install scikit-learn for you.

Now, let’s talk about importing real data. In this tutorial, we’ll use a link file with import house prices as a target value. You can import data into Pandas using the sklearn.datasets function. We load in a dataset from Scikit-Learn and pack it into a DataFrame:

import pandas as pd
import numpy as np
from sklearn.datasets import fetch_california_housing

# Target column is under ch.target, rest is under ch.data
ch = fetch_california_housing(as_frame=True)
df = pd.DataFrame(data=ch.data, columns=ch.feature_names)
df['MedHouseVal'] = ch.target

df.head()


And the same with Python4Delphi_maXbox5:

execstr('from sklearn.datasets import fetch_california_housing');
execstr('housing = fetch_california_housing()');
//# Target column is under ch.target, the rest is under ch.data
execstr('ch = fetch_california_housing(as_frame=True)');
execstr('df = pd.DataFrame(data=ch.data, columns=ch.feature_names)');
execstr('df["MedHouseVal"] = ch.target; print(df.head())');

Checking for correlation, and quantifying correlation is one of the key steps during exploratory data analysis and forming hypotheses, for example the correlation between house value and house age.

“Covariance” indicates the direction of the linear relationship between variables. “Correlation” on the other hand measures both the strength and direction of the linear relationship between two variables.

Now, let’s move on to visualizing the data in a correlation matrix. Matplotlib and Seaborn are great libraries for creating charts and graphs. To get the correlations between all of the numerical features above, we simply call df.corr() (which defaults to Pearson Correlation). Since a tabular format isn’t really intuitive or understandable— let’s plot this as a heat map with the help from seaborn:

import seaborn as sns
import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(10, 6))

sns.heatmap(df.corr(), ax=ax, annot=True)

// Python4Delphi
execstr('fig, ax = plt.subplots(figsize=(10, 6))             '+LF+
        'plt.title("corr. matrix - california_housing mX5")  '+LF+   
        'sns.heatmap(df.corr(),ax=ax,annot=True); plt.show() ');

The script you get at: https://sourceforge.net/projects/maxbox5/files/examples/1382_data_science_stuff140_1_py_uc.txt/download

One of the fundamental activities in statistics is creating models that can summarize data using a small set of numbers, thus providing a compact description of the data. In this correlation we will discuss the concept of a statistical model and how it can be used to describe data.

Corralation Matrix of House Prices (MedHouseVal)

We see a strong correlation between house prices and income (MedInc) of 69% positive correlation of 20640 records. Another correlation is between income and rooms with 33%. By the way: the top correlation of 85% is a typical covariance of average rooms and average bedrooms relationship!

We can also see a single target variable and would like to show which features correlate with it. We’ll calculate the correlations with df.corr() and then subset the resulting DataFrame to include only the target column:

//Get Correlation to Target Variable
     execstr('corr = df.corr()[["MedHouseVal"]]         '+LF+
             'plt.title("Correlation to Target - mX5")  '+LF+  
             'sns.heatmap(corr, annot=True);plt.show()  ');   
//Thanks the idea of: https://stackabuse.com/bytes/calculate-correlation-of-dataframe-featurescolumns-with-pandas/

Correlation to Target

How do we calculate correlation matrix?

The correlation matrix above shows the correlation coefficients between several variables related to house value: Each cell in the table matrix shows the correlation between two specific variables (features):

type DMatrix = array of array of double;

procedure CalculateCorrelationMatrix(data:DMatrix; var matrix:DMatrix);
var i,j,n: Integer;
begin
  n:= Length(data);
  for i:= 0 to n - 1 do begin
    for j:= 0 to n - 1 do 
      matrix[i][j]:= PearsonCorrelation(data[i], data[j]);
  end;
end;

The funny thing is the type DMatrix, it’s a double array of course but als an array of double :).

The second part visualizes in a short fragment simulation the problem of overfitting data (advanced concept). In statistics, a model is meant to provide a similarly condensed description, but for data rather than for a physical structure. Like physical models, a statistical model is generally much simpler than the data being described;

The basic structure of a statistical model is: data=model+error

This code snippet trains a support vector regression (SVR) or linear regression model, predicts the target values for the test set, and then calculates and prints the R² score and Mean Squared Error (MSE) for the model. Feel free to adapt it to your specific dataset and model!

Understanding the fit() Method
The fit() method in Scikit-Learn is used to train a machine learning model. Training a model involves feeding it with data so it can learn the underlying patterns. This method adjusts the parameters of the model based on the provided or simulated data.

execstr('model = SVR(gamma="auto") #=scale              '+LF+ 
        'print(model)                                   '+LF+ 
        'model.fit(x,y)                                 '+LF+ 
        'pred_y = model.predict(x)                      '+LF+ 
        '                                               '+LF+ 
        'for yo, yp in zip(y[1:15,:], pred_y[1:15]):    '+LF+ 
        '  print(yo,yp)                                 ');   

execstr('x_ax=range(Datarange)                                       '+LF+
        'plt.scatter(x_ax, y, s=5,color="blue",label="original")     '+LF+
        'plt.plot(x_ax,pred_y, lw=1.5,color="red",label="predicted") '+LF+
        'plt.title("high variance - be overfitted mX5")              '+LF+
        'plt.legend()                                                '+LF+
        'plt.show()                                                  ');  

execstr('score=model.score(x,y)                   '+LF+
        'print("Score:",score)                    '+LF+
        '                                         '+LF+
        'mse =mean_squared_error(y, pred_y)       '+LF+
        'print("Mean Squared Error:",mse)         ');

Scikit-learns model.score(X,y) calculation works on co-efficient of determination i.e R² is a simple function that takes model.score= (X_test,y_test). It doesn’t require y_predicted value to be supplied externally to calculate the score for you, rather it calculates y_predicted internally and uses it in the calculations.

Overfitting a model

As we can see the variance of predicte is to high. In machine learning, overfitting occurs when an algorithm fits too closely or even exactly to its training data, resulting in a model that can’t make accurate predictions or conclusions from any data other than the training data.

What is Overfitting? | IBM

Overfitting defeats purpose of the machine learning model. Generalization of a model to new data is ultimately what allows us to use machine learning algorithms every day to make predictions and classify data.

Data Science Code Presentation

Max Kleiner — Fri, 01 Nov 2024 14:57:00 +0000

Funny talking about code in only 94 seconds. Are you excited to take part in the Enterprise Article Showcase Challenge by Embarcadero? Here is your chance to make some money and share your valuable experience at the same time!

JavaScript Loader

Max Kleiner — Thu, 31 Oct 2024 22:04:07 +0000

Loaders are transformations that are applied to the source code of a module or a script. They allow you to pre-process files or html with javascript inside as you import or “load” them. Thus, loaders are kind of like “tasks” in other build tools and provide a powerful way to handle front-end build steps.
The idea is to download a JS programm and run it native locally in a runtime browser (webview2) with some modifications in it, based on a script you deliver before. I call this a multiple deployment as a fixture:

const
  SINWAVES2URL= 'https://raw.githack.com/maxkleiner/maXbox4/master/assets/sinwavesjs.html';
aMS:= TMemoryStream.Create;
 try
   HttpGet(SINWAVES2URL, amS)
   writeln('urlcontent size: '+itoa((ams.size)));
   aMS.Seek(0, 0);
   memoHTML.lines.loadfromstream(aMs);
   //javascript fixture_
   memoHTML.text:= StringReplace(memoHtml.text,'frequency = 20;','frequency = 30;',[rfReplaceAll]); 
   memoHTML.text:= StringReplace(memoHtml.text,'Sine Wave</h3>','Sine Wave F30</h3>',[rfReplaceAll]); 
   navigatetoString(memoHTML.text);
 finally
   aMS.Free
 end;

For example, you can use loaders to tell a website to load a CSS with javascript file and to modify parameters in JavaScript before you run it in a local browser of webview2.

Loaders can be chained. Each loader in the chain applies transformations to the processed resource for example load the url as a stream in a memo with lines, modify two parameters (frequency and title in our example) an run it with navigatetoString(memoHTML.text); on a browser:

with TEdgeViewForm.create(self) do begin
   PageControl1.ActivePageIndex := 1;
   edit1.text:= SINWAVES2URL;
   aMS:= TMemoryStream.Create;
   try
     HttpGet(SINWAVES2URL, amS)
     writeln('urlcontent size: '+itoa((ams.size)));
     aMS.Seek(0, 0);
     memoHTML.lines.loadfromstream(aMs);
     //javascript fixture_
     memoHTML.text:= StringReplace(memoHtml.text,'frequency = 20;','frequency = 30;',[rfReplaceAll]); 
     memoHTML.text:= StringReplace(memoHtml.text,'Sine Wave</h3>','Sine Wave F30</h3>',[rfReplaceAll]); 
     navigatetoString(memoHTML.text);
   finally
     aMS.Free
   end;    
   showmodal
   free;
 end;

The script is available at:
javascript_execute2_5_script

When distributing your application, there are a few ways you can ensure the WebView2 Runtime is on client machines.
The Bootstrapper evergreen is a tiny installer that downloads the Evergreen Runtime matching device architecture and installs it locally. There is also a Link that allows you to programmatically download the Bootstrapper.

One of the main benefits of using the Edge WebView2 Runtime is its support for a latest web standards such as HTML5, CSS3, and JavaScript ECMAScript 2020. This means that developers can take full advantage of this web technologies to create high-quality user experiences independent from the standard browser.

Unlike Electron and CEF (Chromium Embedded Framework), it’s installed on the OS for use by any app that needs it, so apps no longer need to include it in their installer (but can if you want to). It will become pervasive on Windows through Win 10 updates and inclusion in Win 11.

Google Directions Script

Max Kleiner — Sat, 28 Sep 2024 16:36:27 +0000

The St. Thomas Church (German: Thomaskirche) is a Lutheran church in Leipzig, Germany, located at the western part of the inner city ring road in Leipzig’s central district. Martin Luther preached in the church in 1539. It is associated with several well-known composers, especially Johann Sebastian Bach, who was its Thomaskantor (music director) from 1723 until his death in 1750. The church holds his remains.

function TAddressGeoCodeOSM8(AURL, location, aApikey: string): tlatlong;
var Httpreq: THttpRequestC; httpres: string;
    Body: TMultipartFormBody;
    jsn: TMcJsonItem;
begin
  httpreq:= THttpRequestC.create(self);
  httpreq.headers.add('Accept: application/json; charset=utf-8');
  httpreq.useragent:= USERAGENT4;
  httpreq.SecurityOptions:= [soSsl3, soPct, soIgnoreCertCNInvalid];
  try
    if httpreq.get(Format(AURL,[location])) then begin
       //httpres:= (httpreq.Response.ContentAsString)
       httpres:= (httpreq.Response.ContentAsUTF8String)
       //writeln('conttype '+httpreq.Response.ContentType);
       writ('debug back '+formatJson(httpres));
       jsn:= TMcJsonItem.Create;
       jsn.AsJSON:= httpres;
       result.lat:= jsn.at(0,'lat').asnumber;
       result.long:= jsn.at(0,'lon').asnumber;
       result.descript:= Format('Coords: lat %2.5f  lng %2.5f %s place_id: %d',
                                [result.lat,result.long,jsn.at(0,'display_name').asstring,
                                                        jsn.at(0,'place_id').asinteger]); 
    end else Writeln('APIError '+inttostr(Httpreq.Response.StatusCode2));
    //StrReplace(httpres, '[{', '{');
  finally 
    writeln('Status3: '+gethttpcod(httpreq.Response.statuscode2))
    httpreq.Free;  
    sleep(200)
    jsn.Free;
  end; 
end;

OSM _to: Coords: lat 51.33933 lng 12.37260 Thomaskirche, 18, Thomaskirchhof, Zentrum, Mitte, Leipzig, Sachsen, 04109, Deutschland place_id: 118838745
get geocoords: lat: 51.3393 - lon: 12.3726
mX5🐞 executed: 26/09/2024 09:52:14 Runtime: 0:0:4.38 Memload: 62% use

TDirection is working as a URL Builder:

procedure TDirectionsBtnGoGoogleClick(Sender: TObject);
Var
  LocFrom,LocTo:RNavigateLongLat;
  Long,Lat:Double;
begin
  LocFrom:=RNavigateLongLat.create;
  Locto:=RNavigateLongLat.create;
  Long:=RealFrmDegreeText(EdtLong.Text);
  Lat:= RealFrmDegreeText(EdtLat.Text);
  LocFrom.CreateDec(Long,Lat);
  Long:=RealFrmDegreeText(EdtLong2.Text);
  Lat:= RealFrmDegreeText(EdtLat2.Text);
  LocTo.CreateDec(Long,Lat);
  // { 0 Start 1 End 3 Center }
  EdtGoogleLink.Text:=LocFrom.GoogleLinkDirectionsTo(LocTo, 0);
  LBlCrowFlies.Caption:='Distance as Crow Flys ='+FormatFloat('0.0km',LocTo.MetresFrom(LocFrom)/1000);
  if CBxGoNow.Checked then
     LocFrom.GoGoogleDirectionsTo(LocTo, 0);
end;

Google Maps helps you discover new places, find directions, and get real-time updates on traffic, public transportation, and more. You can also control your data with privacy settings, use the Google Assistant, and see stories of how people use Google Maps.

http://www.softwareschule.ch/examples/directions6.txt

maXbox5

Max Kleiner — Thu, 08 Aug 2024 20:35:21 +0000

hile maXbox5 appears to be a versatile scripting tool, there's no evidence in the given search
results that it supports languages other than Object Pascal. The focus seems to be on providing
a robust environment for Object Pascal scripting rather than offering multiple language options.

In summary, maXbox5's bytecode interpretation system is a core component of its scripting engine, providing a
balance between performance, cross-platform compatibility, and extensive library support.
The bytecode interpreter allows maXbox5 to execute complex scripts efficiently while maintaining
a high degree of flexibility and functionality across different operating systems and environments.

Dragon Curve 2

Max Kleiner — Thu, 08 Aug 2024 07:51:51 +0000

I want to show the dragon curve in five language soluitons:

Pascal
Python
Turtle
Delphi
Java Script

A dragon curve is any member of a family of self-similar fractal curves, which can be approximated by recursive methods such as Lindenmayer systems as a procedure in Pascal shows:

procedure Dragon(n,a,t:Integer; d,x,y: Double; var b: TBitmap);
  var a1, a2: integer;
begin
 if n <= 1 then begin
   with b.Canvas do begin
     Pen.Color:= random(p);
     MoveTo(Trunc(x + 0.5), Trunc(y + 0.5));
     LineTo(Trunc(x + d *_cos[a]+0.5),Trunc(y+d *_sin[a]+0.5));
     exit;
   end;
 end;
 d:= d * s;
 a1:= (a - t) and 7;
 a2:= (a + t) and 7;
 dragon(n - 1, a1, 1, d, x, y, b);
 dragon(n - 1, a2, -1, d, x + d *_cos[a1], y + d *_sin[a1], b);
end;

Recursively a right curling dragon is a right dragon followed by a left dragon, at 90-degree angle. And a left dragon is a left followed by a right. The same you get also with Python and Turtle in maXbox:

Const DRAGFUNC =
  'def dragon(level=4, size=200, direction=45):   '+LF+
  '  if level:                                     '+LF+
  '      right(direction)                          '+LF+
  '      dragon(level-1, size/1.41421356237, 45)   '+LF+
  '      left(direction * 2)                       '+LF+
  '      dragon(level-1, size/1.41421356237, -45)  '+LF+
  '      right(direction)                          '+LF+
  '  else:                                         '+LF+
  '      forward(size)                             ';

function PyCodeDragonTurtle(imgpath, aAPIKey: string): string;
begin
  with TPythonEngine.Create(Nil) do begin
  //pythonhome:= 'C:\Users\User\AppData\Local\Programs\Python\Python312\';
  try
    loadDLL;
    autofinalize:= false;
    ExecString('from turtle import right,left,forward,speed, exitonclick,hideturtle');
    ExecStr(DRAGFUNC); 
    ExecStr('speed(0)');  
    //ExecStr('hideturtle()'); 
    ExecStr('dragon(6)');
    ExecStr('exitonclick()');
    //result:= (EvalStr('r.json()')); *)
  except
    raiseError;        
  finally      
    Free;
  end; 
 end;
end;

The dragon curve is probably most commonly thought of as the shape that is generated from repeatedly folding a strip of paper in half.

Dragon as Pen.Color:= (p);

The script you get at:
Multilanguage Script

https://sourceforge.net/projects/maxbox/files/Examples/13_General/1320_dragon_curve_51_py.txt/download

with Depth = 9

Pen.Width:= 2; Pen.Color := cllime;

Turtle Sound

Try the sound that turtle with angle as amplitude and step as tone:

procedure DrawDragon2(step, adir: integer; len:real);
begin
  //myturtle:= TJvTurtle.create(self);
  with myturtle do begin
    if (step >-1) and (len >1) then begin
      len:= len /sqrt(2);
      Turn(45*adir);
        DrawDragon2(step-1, +1, len);
      Turn(-90*adir);
        DrawDragon2(step-1, -1, len);
      Turn(45*adir);
    end else      //*)
      moveforward(len )
  end;  
end;

procedure DrawDragon2Sound(step, adir: integer; len:real);
begin
  with myturtle do begin
    if (step >-1) and (len >1) then begin
      len:= len /sqrt(2);
      Turn(45*adir);
      //beep2(440+45, 150)
        DrawDragon2(step-1, +1, len);
      Turn(-90*adir);
      beep2(440-90, 150)
        DrawDragon2(step-1, -1, len);
      Turn(45*adir);
      beep2(440+45, 150)
    end else    //*)
      moveforward(len )
      //beep2(440, 100)
  end;  
end;

JavaScript Embedded

The Microsoft Edge WebView2 control allows you to embed web technologies (HTML, CSS, and JavaScript) in your native apps. The WebView2 control uses Microsoft Edge as the rendering engine to display the web content in native apps.

<!-- DragonCurve.html -->
<html>
<head>
<script type='text/javascript'>
function pDragon(cId) {
  // Plotting Dragon curves. 2/25/17 aev
  var n=document.getElementById('ord').value;
  var sc=document.getElementById('sci').value;
  var hsh=document.getElementById('hshi').value;
  var vsh=document.getElementById('vshi').value;
  var clr=document.getElementById('cli').value;
  var c=c1=c2=c2x=c2y=x=y=0, d=1, n=1<<n;
  var cvs=document.getElementById(cId);
  var ctx=cvs.getContext("2d");
  hsh=Number(hsh); vsh=Number(vsh);
  x=y=cvs.width/2;
  // Cleaning canvas, init plotting
  ctx.fillStyle="white"; ctx.fillRect(0,0,cvs.width,cvs.height);
  ctx.beginPath();
  for(i=0; i<=n;) {
    ctx.lineTo((x+hsh)*sc,(y+vsh)*sc);
    c1=c&1; c2=c&2;
    c2x=1*d; if(c2>0) {c2x=(-1)*d}; c2y=(-1)*c2x;
    if(c1>0) {y+=c2y} else {x+=c2x}
    i++; c+=i/(i&-i);
  }
  ctx.strokeStyle = clr;  ctx.stroke();
}
</script>
</head>
<body>
<p><b>Please input order, scale, x-shift, y-shift, color:</></p>
<input id=ord value=11 type="number" min="7" max="25" size="2">
<input id=sci value=7.0 type="number" min="0.001" max="10" size="5">
<input id=hshi value=-265 type="number" min="-50000" max="50000" size="6">
<input id=vshi value=-260 type="number" min="-50000" max="50000" size="6">
<input id=cli value="red" type="text" size="14">
<button onclick="pDragon('canvId')">Plot it!</button>
<h3>Dragon curve</h3>
<canvas id="canvId" width=640 height=640 style="border: 2px inset;"></canvas>
</body>
</html>

Modify and explore in EdgeView of maXbox5
The Script you find at:

the whole 5 languages script at

Dragon Color Samples

In doing variants of color and density by mod operator and direction in moveforward procedure, you get different images of dragon routine:

end else  begin    //*)
      moveforward(len )
      //beep2(440, 100)
      //beep2(440-90*adir, 450)
      if (adir= -1) and (cn mod 210=1) then begin
        canvas.Pen.Color:= random(clwhite);
        if cn mod 1190=1 then
         //beep2(440-random(110), 950) }
        //PlaySound('INDIGO_WAV',hInstance,SND_RESOURCE or SND_ASYNC);
        playreswav('DRUMLOOP','WAV');
      end;  
      inc(cn)
     end; 
  end;

link to dragon sound color script

Dragon Curve

Max Kleiner — Wed, 07 Aug 2024 11:33:51 +0000

A dragon curve is any member of a family of self-similar fractal curves, which can be approximated by recursive methods such as Lindenmayer systems as a procedure in Pascal shows:

procedure Dragon(n, a, t: Integer; d, x, y: Double; var b: TBitmap);
  var a1, a2: integer;
  begin
  if n <= 1 then begin
     with b.Canvas do begin
       Pen.Color := random(p);
       MoveTo(Trunc(x + 0.5), Trunc(y + 0.5));
       LineTo(Trunc(x + d * _cos[a] + 0.5), Trunc(y + d * _sin[a] + 0.5));
       exit;
     end;
   end;
   d := d * s;
   a1 := (a - t) and 7;
   a2 := (a + t) and 7;
  dragon(n - 1, a1, 1, d, x, y, b);
  dragon(n - 1, a2, -1, d, x + d * _cos[a1], y + d * _sin[a1], b);
end;

Const DRAGFUNC =
  'def dragon(level=4, size=200, direction=45):   '+LF+
  '  if level:                                     '+LF+
  '      right(direction)                          '+LF+
  '      dragon(level-1, size/1.41421356237, 45)   '+LF+
  '      left(direction * 2)                       '+LF+
  '      dragon(level-1, size/1.41421356237, -45)  '+LF+
  '      right(direction)                          '+LF+
  '  else:                                         '+LF+
  '      forward(size)                             ';

function PyCodeDragonTurtle(imgpath, aAPIKey: string): string;
begin
  with TPythonEngine.Create(Nil) do begin
  //pythonhome:= 'C:\Users\User\AppData\Local\Programs\Python\Python312\';
  try
    loadDLL;
    autofinalize:= false;
    ExecString('from turtle import right,left,forward,speed, exitonclick, hideturtle');
    ExecStr(DRAGFUNC); 
    ExecStr('speed(0)');  
    //ExecStr('hideturtle()'); 
    ExecStr('dragon(6)');
    ExecStr('exitonclick()');
    //result:= (EvalStr('r.json()')); *)
  except
    raiseError;        
  finally       
    Free;
  end; 
 end;
end;

The dragon curve is probably most commonly thought of as the shape that is generated from repeatedly folding a strip of paper in half.

The script you get at:
Multilanguage Script

with Depth = 9