Az ad hoc kutatásaim újabb terméke:

A Lolita programnyelv ! - rögtön ki is próbálhatod a web-böngésződben
Nem elkezdeni nehéz, hanem abbahagynod lesz nehéz ♥

Egy a természetes nyelvhez közeli programozási nyelv
, de egyben a halmazelmélet közeli programnyelv is !

Én hiperFizikus = Okos Árnyék, találtam ki Rimaszombatból ♥

Aki ismer legalább 1 db imperatív eredetű programnyelvet, annak e Lolita programozási nyelv sem lesz nehéz .

Jelenleg ott tartok, hogy sikerült objektumosítanom, persze csak egy egyszerű objektumosság lett ! - kb. így néz ki, itt-ott levágva mutatom csak :

const 
f={ 
    cm:{}, 
    hm:{arg:{}, list:{}, bl:{}}, 
    em:{
        ut1:{vez:{}, prog:{}}, 
        ut2:{vez:{}}, 
        ut3:{}
    }, // em_
    mt:{Eval:{}, Index:{}, IDim:{}, Mt:{}, Ablak:{}, ADim:{}, Szim:{}}
} 
; // const_

Jelenleg a mérete 240 képernyő oldal = 7200 sor, és még dolgozok rajta ♥ A Teener kódból lett sok áthozva, de sokat kellet még igazgatnom, amíg pászolva nem lett a Lolita kódhoz . Tulajdonképen ez a 240 oldal kevés vagy sok, ti mekkora oldalmenyiséggel dolgoztok ?

Azért adom meg a kód méretét képernyő oldal számban, mert a soroknál érzékletesebb . És a szgépen helyesen lefutó kód menyisége minősíti a programozót !

Nem érzékletesebb semmivel. A sorok száma egy objektív adat.
A képernyő méret viszont mindenkinél mást jelenthet. Lehet, hogy nálad egy képernyőre 20 sor fér ki 1024X768-as felbontásban.
Másnál meg kifér 80 sor 4K-s felbontásban.
És fordítva.
De mindegy is, neked elnézzük a képernyőnem megadott bármit, még ha rajtad kívül senkinek nem is jelent semmit ez az adat

1 db képernyő oldal = 30 db sor

Amikor 240 db kép. oldal menyiséggel dolgozok, akkor jön elő az a probléma, hogy képes lennék egymagam 5000 kép. oldalnyi méretű kódot is bebillentyűzni, de a természetileg adott testem korlátai miatt nem lehet .

Kérlek titeket, hogy hallgassátok meg ezt az ide kapcsolódó zenét, és 5 percet mi programozók szomorkodjunk egy jót együtt emiatt ♥

https://www.youtube.com/watch?v=BvZY-ycS6vA csak 4.17 perces
Piramis Ha Volna Két Életem - Zeneszöveggel -

Máma reggel 5.00 -tól 15.00 -ig programozgattam, totál elegem van mára ♥

A kifejezések olyan 3/4 része már megvan, most így állnak a dolgok Lolita kód ügyben, ami még változhat:

A következő .js fájlok tartoznak hozzá:
<SCRIPT src = "Lolita_files/a,priori.js" ></SCRIPT>
<SCRIPT src = "Lolita_files/beallit 0.js" ></SCRIPT>
<SCRIPT src = "Lolita_files/prog 1.js" ></SCRIPT>
<SCRIPT src = "Lolita_files/fejes 2.js" ></SCRIPT>
<SCRIPT src = "Lolita_files/cimke 3.js" ></SCRIPT>
<SCRIPT src = "Lolita_files/poszt priori.js" ></SCRIPT>
<SCRIPT src = "Lolita_files/teener Ablak ADim.js" ></SCRIPT>
<SCRIPT src = "Lolita_files/kifej IDim.js" ></SCRIPT>
<SCRIPT src = "Lolita_files/kifej Indexek.js" ></SCRIPT>
<SCRIPT src = "Lolita_files/kifej Matek.js" ></SCRIPT>
<SCRIPT src = "Lolita_files/kifej Szim.js" ></SCRIPT>
<SCRIPT src = "Lolita_files/teener eval.js" ></SCRIPT>

Ez összesen 260 képernyő oldal = 7800 sor ! De nem vészes, mert e "szénakazal" kategorikus struktúraként van elrendezve .

Egy start így fut le benne, már kiforrott folyamat:

1. Kezdi a : Lolita.html weblappal
2. ami a prog 1.js kód
2.1. onclick="f.kapu1()" functionnal indít
2.2. és rendszerint az Ev.Loli() functionhoz lyukad ki
3. ami a bekerül a kifej IDim.js kódba, itt feldarabolódik a kifejezés
4.1. onnan átadódik a kifej Indexek.js kódba, ott darabonként feldolgozódik
4.2. itt egyes kifejezés.tagok a para_cs és para1cs, para2cs, para3cs pótlólagos funcióban kapnak végleges értket
4.3. és itt az egyes kifejezés intervalumok az teener eval.js fájl eval() szerű funcióimon keresztül végül is a kifej Matek.js fájlban lyukad ki, ahol véglegesen történek a kifejezés műveleteinek végrehajtása

5. a többi, mint például a megjelenítés ehhez képest mellékesek .

Csodálatos, hogy ezt minden variációra hiba nélkül végig viszi a 260 kép. oldalon keresztül ♥ Illetve vinné, ha nem fordulnának elő benne minduntalan bugok . Ilyenkor már nem olyan csodálatos, hogy nekem kell e bugok miatt végig bogarásznom ezt a 260 oldalnyi rémséget !

Hogy egy kicsit szokjátok a Lolita prg. ny-et. legyen nektek ez a link:

" A Babylscript egy olyan nemrég kezdődött projekt, amely engedélyezi, hogy a JavaScript angol parancsszavait felcseréljük bármilyen nyelv parancsszavaival, akár menet közben is. Jelenleg még csak a francia és román változat támogatása teljes, de más nyelvű programozók aktív részvételét is várják a projektben. "

[ Szerkesztve ]

No, valami van !
Kész van a kifejezések, de még pár dolgot hozzá kell leprogramoznom:

1. a hidat, igen
2. a változókat, igen
3. a strukturált értékeket, nem most
4. a objektumosságot, nem most
5. a szimultán értékadást, még nem döntöttem
*. pár apróságot, miért ne
6. a primitív diagnosztikát, muszáj lesz
7. az új weblapját, elkerülhetetlen

8. a combo és a ripple funkciókat, csak a következő fázisban

Jelenleg 288 képernyő oldal = 8640 sor, bár ebből 10.6 oldal = 318 sor archív ballasz . De mivel idegileg belefáradtam, ezért a 3. és a 4. kicsivel későbbre került . Szórakoztató egy .js kódocska, mert amikor már azt hiszem, hogy már minden bugot helyrehoztam benne, akkor elbukkan egy új bugocska . Ilyenkor "visítok" a jókedvemben .

Mivel sokat panaszkodtatok, hogy a JS kódomban az azonosítók nem beszédesek, ezért megsajnáltalak titeket, és például így is lehet lesz megadni az aritmetikai műveleteket, pl. :
mt. 3 plusz 4 cm. ok 7

, persze én maradok az:
mt. 3 + 4 cm. ok 7
, alaknál, de hát ha ti úgy szeretitek ...

Ismételten megjegyzem, hogy ez a 288 JavaScript oldal azért van, hogy ti majd bele tudjatok nyúlni, ill. hogy majd szerkeszteni tudjátok ♥

Sajnos nem tudom kivonni magam a politikai zavarástól, ezért csúszott idáig az ütemterv, és ezért a mossa a kedvem a padlót .

[ Szerkesztve ]

Csináltam valami letölthetőt ! Ez bele van építve a Lolita prg. ny. kezelőfelületébe, ott működik .

Kivontam onnan nektek, és itt vehetitek birtokba .
A Lolita programnyelv elméleti szintaxisa ! - mármint ez a weblapja .

Akkor a "híd" = hidDimBejaro() már megvan, pontosabban ilyen: legalábbis jelenleg
function hidDimBejaro(a1){ 
    return Ablak(a1,"¨a.lanc2.") ; // a lanc2() = egyben hidBejaro() is
}; // func_
//    <<>> hidBejaro : 

Hát igen, 10 napja ígértem be nektek, végül is 1 hosszú nap alatt megvolt, de előtte a többi 9 napot is a Lolita prg.ny.-em leprogramozásával töltöttem . Rengeteg mást is kellett rajta csinálnom, mint a hidat, és sajnos a napi politika ténylegesen hátráltat . A végidőkben a Lolita kód mérete csak lassan növekedett, viszont többször is az egész forráskódja átrendeződött általam .

A lanc2() tulajdonképen a tényleges híd() , de nem volt szívem átnevezni hídra , itt alant láthatod :

Object.defineProperty(f.hm.arg, "lanc2", {value: // ez lenne a híd, nem volt szívem átnevezni a hidBejaro -ra 
function (aa02){ // a zárójeles vastag lánchoz van
let e0, a1 ; a1= "" ; e0= aa02 ; 
let an ; an= dia_n +1 ; 
alertBLBL(dia0b,0,"dia0b","arg/arg.lanc2, 0 >"+an+" /: "+jsNL+aa02  ) 
// alert("_ arg/arg.lanc2, 0 >"+an+" /: "+jsNL+aa02)
    if ( inStrBL(aa02,ch166q) && (inLeftT(aa02,"mt. ") || inLeftT(aa02,"mt° ")) ){
            errAlert(ch9801q+" Megkeverted az mt. és az mt' előjeleket ! 
 Hiba 7: az arg.lanc2() functionban jelenkezett ! - kilép ." +jsNL+jsNL +aa02 ) ; recs() ;
    } else if (aa02.kem("°d",ChrW(166))){
        // e0= aa02.replace("mt' ","") ; 
        a1= Ablak( "{"+e0+"}" , "¨a.blokk2.") ; // blokk2
    } else if (aa02.kem("°d",";")){
        // e0= aa02.replace("mt. ","") ; 
        a1= Ablak(e0,"¨a.kifej2.") ; // kifej2
/* ki lett cm-elve. ígyhát hiányzik, emiat a nagy kerülővel a para1cs -be kapja meg a "¨a.lanc2." -át 
    } else if (aa02.kem("°d"," ")){
        // e0= aa02.replace("mt° ","") ; 
        a1= Ablak(e0,"¨a.lanc2.") ; // lanc2
*/
// , "ciklo ", "show "
    } else if ( InLeftT([aa02],xFejek3) ){ // **.replace() nélküli, nevesített mt' , és bővíthető 
        a1= Ablak(aa02,"¨a.lancSzem.") ; // lancSzem 2x
    } else if ( InStrBL([aa02],xFejek4) ){ // ez is, és bővíthető: , " Func " mintha nem való de csábító 
        a1= Ablak(aa02,"¨a.lancSzem.") ; // és ...
    } else { // ???
        // a1= Ablak(aa02,"¨a.lanc1.") ; // mivel az vékony o o o => vastag o o o 
        a1= Ablak(aa02,"¨a.kifej1.") ; // e kifej1 tartalmazza a láncot is, ami a para1cs -ben kapja meg a "¨a.lanc1." -jét 
    }; // if_
alertBLBL(dia00b,0,"dia00b","arg/arg.lanc2, 00 "+an+"< /: "+jsNL+jsNL+a1  ) 
// alert("_ arg/arg.lanc2, 00 "+an+"< /: "+jsNL+jsNL+a1)
return a1 ; 
}
}); // obj def pro
//    <<>> arg.lanc2 : 

Holnap elkezdem a változókat megcsinálni, majd a változókhoz szorosan tartozó szimultánt átmásolni, illeszteni és kipótolni . Egyszer csak készen lesz az a minimum, hogy feltessem nektek a NET-re .

Jelenleg a nyers mérete 323 képernyő oldal = 9690 sor {ebben már nincs benne a volt balasz méret,már kidobtam}, ez soknak tűnhet, de nagyon jól van belsőleg elrendezve, már csak azért is, mert akkor nem tudnák vele ilyen gyorsan dolgozni: pl. a minduntalan felszálló bugokat lassú és nem egy vidám dolog ezen a 323 kép. oldalon keresztül kijavítani .

Csak remélhetem, hogy a továbbiakban már gyorsabban fogok tudni haladni az #7 ütemterven ♥ - ha a fenti meglesz, majd ismét jelentkezek .

válasz: ( #9915 Bzozoo hiperFizikus #9914 ) -nak !

, épen most összesítettem: már 363 képernyő oldalas ♥ - a szimultán felénél tartok, a változóit már nem a JS -ből veszi hanem egy egyszerű saját tárból .

Az objektum rendszere, egy része ilyenre változott:

<script> // távlati, zsugorított objektum rendszer, 
const 
    Napq={}, napq={} , napFutarq={} , 
    tenyTarq={Textq1:[], Textq2:[], Encikq1:[], Encikq2:[], Lexikq1:[], Lexikq2:[], Dimq1:[], Dimq2:[] }, elemTenyq={utasq:{}, eljarq:{}, fuggq:{} }, idoTenyq={} , 
    tenyIroq={} , tenyOlvasoq={} , 
    reTenyMaq={ringq:{}, cimesq:{}, editerq:{} }, areTenyMaq={dobq:{} } , 
    poemq={} ; // a poem magyarul versek még kidolgozatlan 
</script>

Az fájl.js -jei jelenleg a következők:

      <SCRIPT src = "Lolita_files/priori/beallit prog.js" ></SCRIPT>
<SCRIPT src = "Lolita_files/a,priori.js" ></SCRIPT>
   <SCRIPT src = "Lolita_files/priori/go unicode IPA.js" ></SCRIPT>
      <SCRIPT src = "Lolita_files/priori/beallit diag.js" ></SCRIPT>
         <!-- a " beallit prog.js " kivéte, a ; ch3Err1 = ch9801q ; miat -->
      <SCRIPT src = "Lolita_files/priori/beallit kifej.js" ></SCRIPT>
      <SCRIPT src = "Lolita_files/priori/beallit kebzok.js" ></SCRIPT>
   <SCRIPT src = "Lolita_files/priori/panel.js" ></SCRIPT>
   <SCRIPT src = "Lolita_files/priori/fejes 2.js" ></SCRIPT>
      <SCRIPT src = "Lolita_files/priori/prog kapu.js" ></SCRIPT>
      <SCRIPT src = "Lolita_files/priori/prog commentek.js" ></SCRIPT>
      <SCRIPT src = "Lolita_files/priori/prog argumentumok.js" ></SCRIPT>
      <SCRIPT src = "Lolita_files/priori/prog elemek.js" ></SCRIPT>
   <SCRIPT src = "Lolita_files/priori/cimke 3.js" ></SCRIPT>
   <SCRIPT src = "Lolita_files/priori/teener Ablak ADim.js" ></SCRIPT>
      <SCRIPT src = "Lolita_files/priori/kifej IDim.js" ></SCRIPT>
      <SCRIPT src = "Lolita_files/priori/kifej Indexek.js" ></SCRIPT>
      <SCRIPT src = "Lolita_files/priori/kifej Matek.js" ></SCRIPT>
      <SCRIPT src = "Lolita_files/priori/kifej Szimu.js" ></SCRIPT>
   <SCRIPT src = "Lolita_files/priori/teener eval.js" ></SCRIPT>
<SCRIPT src = "Lolita_files/poszt priori.js" ></SCRIPT>

Ez a 363 oldal nem annyira nehéz, hanem inkább sok .

[ Szerkesztve ]

Programozásnál nem szokás include-olni nagybetűkkel / szóközökkel rendelkező fájlnevű elemeket. Nem mondták még?

... tudjátok az úgy van, hogy ha írsz egy magán kódot, akkor nagy valószínűséggel soha senki más nem fog bogarászni benne rajtad kívül ! - legalábbis ingyen nem .

Mellékesen megjegyzem, hogy egy kicsit meg vagyok fázva, ha nem jövök helyre és ágynak dőlök tőle, akkor megint tovább csúszik az ütemtervem .

[ Szerkesztve ]

Jé, mit találtam ? - egy rokon topicot :

https://itcafe.hu/tema/re_unalmasak_a_programkodok_bosszantsd_magad_pikto/friss.html

megjegyzem:
A szimultánban már csak pár dolgot kell, a változóknál meg a másik felét . Pillanatnyilag 380 képernyő oldal = 11400 sor . Így aztán, ha valami egyszerűbb formázás újítást akarok végig vinni e 380 oldalon, akkor az nem egy vidám dolog .

probléma lesz, hogy lassú, mert :

wu1? ı wu2? ı wu3? ı wu4? :== 5 + 1 ı 5 + 2 ı 5 + 3 ı 50 + 1 ; wu1? ı wu2? ı wu3? :==. wu4?
, ok : 91db char és 170 mili secund ; cm. egy kicsit sok

= = = .¨ wu11? .~. wu12? .~. wu13? .~. 5 + 2  ~  :== .¨ wu21? ı wu22? ı wu23? :=: 5 + 1 ı 5 + 2 ı 5 + 3  ~   := .¨ wu31? ı wu32? ı wu33? :=: 5 + 2
, ok : 146db char és 98 mili secund ; cm. egy kicsit lassú

, vagyis 10 db ilyen már kb. 1 másodperces lenne ! - legalábbis az én régies{Windows 7} laptopomon . Egészen biztos, hogy ebben a fázisban időhiány miatt nem fogok tudni gyorsítókat rakni belé .

Hiba nélkül lefutott:
> 302db,2db char,sor és 532 mili secund ;
> 384 kép. oldal
> ok

wb11? ı wb12? ı wb13? ı wb21? ı wb22? ı wb23? ı wb31? ı wb32? ı wb33? :== 5 + 1 ı 5 + 2 ı 5 + 3 ı 50 + 1 ı 50 + 2 ı 50 + 3 ı 500 + 1 ı 500 + 2 ı 500 + 3 ; [wa11?, wa12?, wa13?] ı [wa21?, wa22?, wa23?] ı  [wa31?, wa32?, wa33?] :=.= [wb11?, wb12?, wb13?] ı [wb21?, wb22?, wb23?] ı  [wb31?, wb32?, wb33?]

tenyTarq.Lexikq2 4. azon, ertek /: m4

0: wb11? : 6
1: wb12? : 7
2: wb13? : 8
3: wb21? : 51
4: wb22? : 52
5: wb23? : 53
6: wb31? : 501
7: wb32? : 502
8: wb33? : 503
9: wa11? : 6
10: wa12? : 7
11: wa13? : 8
12: wa21? : 51
13: wa22? : 52
14: wa23? : 53
15: wa31? : 501
16: wa32? : 502
17: wa33? : 503

[ Szerkesztve ]

Én kitaláltam egy újfajta commentelési módszert, jó nem csak a Lolitámhoz ♥ !

Duma helyet lásd e kisebb példámat ! :

Array.prototype.es = function (cq3){ //
let xq, xeq ; xeq= this ;
for (xq=0 ; xq < UBound(xeq) ; xq++){
xeq[xq] = xeq[xq]+cq3 ;
}; // if
return xeq ;
};
// << >> es :

/*
új es : func **(cq3){ //
defike: xq, xeq ; xeq -> this ;
. . . . . ciklo.for (xq=0 ; xq < UBound(xeq) ; xq++){
. . . . . . . . . . xeq[xq] = xeq[xq]+cq3 ;
. . . . . } ciklo-vége ;

vissza.kapod.nesze: xeq ; // volt return
} func-vége ;
*/

Tehát nem soronként és nem a functionba kell a kommentjeiteket beleraknotok, hanem így ahogy fent mutattam, külön és alá, mert ekkor a /* ... */ közé azt a holisztikus pszeudokódot teszed, amihez csak kedved van .

[ Szerkesztve ]

Egy jól sikerült hozzászólásom, általában a programozásról :
lásd #19040

A pillanatnyi helyzet :
1. az értékadást akartam folytatni az összetett egyenlőséggel, sikerült is, már az utolsókat teszteltem, amikor

2. az diagnosztikájához egyvalamit hozzá akartam még programozni, ez is sikerült, már az utolsókat teszteltem, amikor

3. az objektum.halmaz rendszerét egy kicsit megújítottam, ez is sikerült, már az utolsókat teszteltem, amikor
, 448 db képernyő oldalas

4. új váz feldolgozó találtam ki hozzá, ez még pillanatnyi terv, tehát nincs is tesztelve
, talán jelentősen kevesebb kép. old. lesz belőle

Igazán sajnálom ♥

Ez mar csak ilyen

Hogy annyira ne unatkozzatok:

https://www.reddit.com/r/hungary/comments/13rdyyu/panel_lakáA1sodban_tartsál_étkezésre_nyulat/

Az az angol nyelvű www.reddit.com fórumos portálnak a magyar nyelvű részlege . Az egyik topikja nemrég foglakozott egy kicsit "velem" .

Nem tudtak zöld ágra vergődni Lolival . De ez csak azért van, mert még nem láttátok a második felét .

Pillanatnyilag egészen jól haladok vele - leszámítva a zaklatóimat - csak az eredeti ütemtervemnek lett annyi . Most a képernyő oldalszámát sem tudom megállapítani, mert épen 2 db szék közt tornászok, pontosabban a leprogramozás rángat engem madzagon és nem fordítva ! - de legalább bizakodóbb lettem, hogy az egésznek lesz valami értelme is .

A reddit által ajánlom ezt a félig-szakmai linket:
https://hu.wikipedia.org/wiki/TempleOS

, idézet e WP weplapról:
" Az integrált fejlesztői környezet számos funkcióval rendelkezik, mint például képek beágyazása kódba. A program által használt nem-sztenderd szövegformátum (DolDoc) támogatja hiperlinkek, képek és 3D modellek beágyazását egy ASCII szövegbe. Így programok forráskódjában szerepelhet akár egy harckocsi forgó modellje is mint komment. Támogatott a JIT fordítás is.[11] Davis úr összesen 100 000 sornyi = 3300 kép. old. kódot írt az operációs rendszere számára. [4] "

Minden jót nektek ♥

https://hvg.hu/360/20230604_hvg_muholdas_telefonalas_teljes_lefedettseg_sms_hanghivas_5g_mobilhalozat

" Hamarosan nem lesz gond, ha nincs földi térerő – és ez lesz az okostelefonok igazi nagy újítása "

https://hvg.hu/tudomany/20230601_opera_bongeszo_aria_mesterseges_intelligencia_oldalsav_chatgpt_integracio

, "a ChatGPT benne lesz a böngésződben" : alig várom ...

Csak hogy vannak olyan laptopok is, amik Wi-Fi módon kommunikálnak . Ha ezek is térerő nélkül kommunikálhatnak majd és bejön rajtuk az ChatGPT "úr" , akkor az érdekes lesz ♥
= +

más:
Egyébként jól haladok, úgy látszik a "második szék" lesz az igazi . De azon még dolgoznom kell, több prg. idő kellesz neki !
<-

A programod pszeudokódjának egyes részeit Plankalkül alakúra is veheted ♥

A ChatGPT motor ezt a HTML kódot ajánlotta a "Plankalkül szerű" függőleges kis részek megjelenítésére, még nem próbáltam ki :

User = én
... de van e ezért valami html kódod még ?

ChatGPT
Igen, itt van egy példa arra, hogyan alkalmazhatod a CSS stílusokat a függőleges szöveg elrendezésére:

htmlCopy code<!DOCTYPE html>
<html>
<head>
  <style>
    .vertical-text {
      writing-mode: vertical-lr;
      text-orientation: upright;
      white-space: nowrap;
      font-family: Arial, sans-serif;
      font-size: 14px;
      line-height: 1.5;
    }
  </style>
</head>
<body>
  <div class="vertical-text">Függőleges szöveg</div>
  <div class="vertical-text">Másik függőleges szöveg</div>
</body>
</html>

Ebben a példában a writing-mode tulajdonsággal a függőleges írásmódot állítjuk be, míg a text-orientation tulajdonsággal az álló helyzetet definiáljuk. A white-space: nowrap tulajdonság megakadályozza a szöveg sortörését, így egymás alatt jelennek meg a függőleges szövegek.

Ezenkívül beállíthatod a kívánt betűtípust, betűméretet és sorvázlatot a saját igényeid szerint a font-family, font-size és line-height tulajdonságokkal.

Természetesen ezt a kódot tovább finomíthatod és testre szabhatsz más stílusokkal is, hogy még jobban illeszkedjen az elképzeléseidhez.

[ Szerkesztve ]

I. Jelentés a Lolita programnyelvem állásáról !

Arról szól, hogy miben segít majd a ChatGPT nekem .

Az én Lolita-kód programnyelvem rokona a következőknek " MathJax és a KaTeX " , csak én mindig sajnálom magamat, amikor jobb verzióval programozom le a Lolita és a Lolita másnevű régebbi verzióit ♥

User = én
Mutass be példakódot ezekre !

ChatGPT
Természetesen! Itt van egy példakód, amely bemutatja, hogyan használhatjuk a JavaScriptes " MathJax és a KaTeX " könyvtárakat a matematikai kifejezések megjelenítésére:

MathJax példakód:
HTML fájl:

htmlCopy code<!DOCTYPE html>
<html>
<head>
  <title>MathJax Example</title>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/MathJax.js?config=TeX-AMS_HTML"></script>
</head>
<body>
  <h1>MathJax Example</h1>
  <p>Az alábbi képlet az Euler-formula:</p>
  <div>
    \(e^{i\pi} + 1 = 0\)
  </div>
</body>
</html>

Ebben a példakódban a MathJax könyvtárat beágyaztuk a fejlécbe, majd a div elemben megjelöltük a LaTeX szintaxisban írt matematikai kifejezést. A MathJax automatikusan észleli és megjeleníti a kifejezést a megfelelő formában.

KaTeX példakód:
HTML fájl:

htmlCopy code<!DOCTYPE html>
<html>
<head>
  <title>KaTeX Example</title>
  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/KaTeX/0.11.1/katex.min.css">
  <script src="https://cdnjs.cloudflare.com/ajax/libs/KaTeX/0.11.1/katex.min.js"></script>
</head>
<body>
  <h1>KaTeX Example</h1>
  <p>Az alábbi képlet az Euler-formula:</p>
  <div>
    $$e^{i\pi} + 1 = 0$$
  </div>
</body>
</html>

Ebben a példakódban a KaTeX könyvtárat beágyaztuk a fejlécbe, majd a div elemben megjelöltük a LaTeX szintaxisban írt matematikai kifejezést a $$ jelek között. A KaTeX automatikusan észleli és megjeleníti a kifejezést a megfelelő formában.

Ezek a példakódok egyszerűen bemutatják a MathJax és a KaTeX használatát matematikai kifejezések megjelenítésére.

Természetesen mindkét könyvtárnak sokféle beállítási lehetősége és további fejlett funkciója van, amelyeket testreszabhatunk az igényeink szerint.

[ Szerkesztve ]

A Morpheus6v1(){ } és a Morpheus7v1(){ } függvényem - mindenki örömére - relativizálják az imperatív programnyelveket ♥

Ez a relativizálás azt jelenti, hogy =def az eddig kifejlesztett összes imperatív programnyelv alprogramját - amit leggyakrabban function, procedure, metod ilyesmiknek nevezik - átírja JavaScript alprogrammá{function}, majd le is futtatja ! - az eredmény meg láthatóan megjelenik a böngésződ konzoljában .

E két fenti link honlapja itt van !

Mivel ti jól tudtok programozni, ezért a forráskódján is változtathattok .

[ Szerkesztve ]

https://www.youtube.com/watch?v=qQXXI5QFUfw 6.47 perces
NEW! Most Popular Programming Languages 1965 - 2022


https://www.youtube.com/watch?v=iNI9QmnGiOE 7.20 perces
Most Popular Programming Languages 1965 - 2023
, illusztrációs és narrátoros ; nekem nem tetszik, de másoknak tetszhet ;


https://www.youtube.com/watch?v=Td08ovJ9M00 3.28 perces
Top 20 Country by High-Technology Exports (1989-2019)


https://www.youtube.com/watch?v=17rm0T1JjWU 4.51 perces
A VILÁG LEGNAGYOBB CSÚCSTECHNOLÓGIA EXPORTŐREI
, fekete háttér + szimbolikus grafika ;



Ezek mind "relativizálódni" fognak, és végül is csak a JavaScript félék és a Lolita programnyelvem marad a csúcson ! ♥

Elkészítettem nektek a Morphius7v2(){ } hátér függvényt is .

Amíg a Morphius7v1(){ } függvényt a forráskódja ismerete nélkül is használhatjátok, addig a Morphius7v2(){ } függvény használatához minimális JavaScript programozási gyakorlat szükséges . Az, hogy a Morphius7v1(){ } függvényt a forráskódja ismerete nélkül is használhatjátok avval a hátránnyal jár, hogy ugyan tág, de véges lehetőséget biztosít a kortárs programnyelvek function féléinek relativizálására, ezért tulajdonképen csak a bevezetőnek alkalmas .

Hanem a Morphius7v2(){ } függvénynek nincsenek korlátai, mindegyik kortárs programnyelvet kötöttség nélkül relativizálni tudja . Csak annyit kell érte tenned, hogy lista[x][y] tömbben az x és y egész szám értékeket pontosan beírogatod a forráskódjában . És ezért mindent elérhetsz vele a programnyelvek function féléinek átírásakor, de tényleg mindent .

Ha adaptálni szeretnéd ezt a fontos és alapos Morpheus7v2(){ } megoldásomat, akkor kattints ide !

[ Szerkesztve ]

https://erdosattilask01.lapunk.hu/a-kommentek-szeriaja-1213905
A kommentek szériája !

Egy plusz kis lépés az általános tokenizáló programnyelvem felé, amit - mint már mondtam - Lolita prg-ny.-nek neveztem el .

Nem tudom egyszerre az egész hócipőt betenni nektek, mert bonyolult és méretes .

User = én
Van-e már kész erre az életjátékra JavaScript program ?

ChatGPT
Igen, az Életjátékra számos JavaScript program és implementáció elérhető a különböző fejlesztői közösségek és projektben. Az Életjáték implementálása JavaScript-ben meglehetősen elterjedt, mivel a nyelv alkalmas erre a célra. Ezek az implementációk általában HTML és Canvas elemeket használnak a játék megjelenítésére a böngészőben.

Ezek közül néhány közismert Életjáték JavaScript implementáció:
Conway's Game of Life by Gabriel Rinaldi: Egy egyszerű és letisztult megvalósítás a játék szabályaival. GitHub projekt

The Nature of Code by Daniel Shiffman: Daniel Shiffman készített egy szép és részletes példát a "Nature of Code" című könyvében, amelyben bemutatja, hogyan lehet az Életjátékot JavaScript-ben elkészíteni. Nature of Code - Életjáték példa

Phaser.js: A Phaser egy HTML5 játékkeret, amely lehetővé teszi az Életjáték könnyű implementálását és a játék fejlesztését is. Phaser.js hivatalos oldal

p5.js: A p5.js egy kreatív programozás és grafika keretrendszer, amelynek segítségével egyszerűen létrehozhatod az Életjátékot is. p5.js Életjáték példa

Ezek a példák segítségül szolgálhatnak a saját Életjáték alkalmazásod létrehozásához JavaScript segítségével. Válaszd ki az implementációt, amely a számodra legalkalmasabb, és azzal kezdd a fejlesztést.

A logikai műveletek szériám ilyen lesz és hamarosan működni is fog és ki is próbálhatjátok nemsokára . Most pedig a félig kész működő előzetesét próbálhatjátok csak ki:

---------------------------------------------------

Én most a logikai Boole műveleteknek a saját variációimra alkalmaztam, környezetfüggő módon . Hamarosan készen lesz a Morphius1v2(){ } függvény is, ami majd működésre is bírja e Boole variált alakú műveleteimet, de addig is szokjatok már mist is hozzá, hogy 1-2 nap múlva könnyebb legyen a használata .

Ha adaptálni szeretnéd ezt a felforgató és fontos Morpheus4v2(){ } megoldásomat, akkor kattints ide !

És sikerül, készen lett !

Most már a Morphius1v2(){ } függvényem is megy, amivel a Boole algebra műveleteinek és értékeinek tetszőleges azonosítókat adhatsz ! Az én azonosítóim egy széria szerint lettek megalkotva, ajánlom mindenkinek, de nem kötelezőleg !

Ha adaptálni szeretnéd ezt a felforgató és fontos Morphius1v2(){ } és Morpheus4v2(){ } megoldásomat, akkor kattints ide !

Evvel is az a célom, hogy a fizetős imperatív programnyelveket relativizáljam ! - relativizáljuk őket együtt .

[ Szerkesztve ]

A legújabb webprogramom a matematika leprogramozására 3/4 részben elkészült . És mivel már egy ideje hitegetlek titeket hogy 1-2 nap múlva készen lesz, és készen is lesz, de hogy azért lássátok, hogy van értelme várni rá, ezért belinkelem nektek a weboldalát, de még letöltés lehetőség nélkül ♥


Remélem nem bánjátok meg, ha megnézitek !

https://erdosattilask01.lapunk.hu/a-fuggoleges-algebra-1213911
A függőleges algebrám !

Ajánlom az ad hoc tudományok polcára .

Evvel még jobban lehet-lesz relativizálni a fizetős programnyelveket !

Az olyasmi mint egy programnyelv, egyfajta előzetese a Lolita programnyelvemnek, ami már több mint féléve ígérgetek nektek !

Sikerült megcsinálnom, hogy a függőleges algebrám az összes imperatív szerű programnyelv függvénykönyvtárát imitálja { = relativizálja} egy meglehetősen egyszerű JavaScript function !

Így néz ki, tehát valóban kicsi és egyszerű, persze vannak még hozzá tartozói :

window.operáló3 = function(a1,a2,a3,a4) { // környezetfüggő cserélés és eval() / 
    switch (a3) {
    case "Cxx" :
        break;
    case "JavaScript" : case "Pithon" : 
    default:
        return eval(operálóB(xaCinkezo2hu( a1, a4.parlist1(Chr(8226),Chr(8227)) )))  ; 
    }; // switch_
}; // func_

Mivel az imperatív szerű programnyelvekből sok van, ezért mindenkinek az általa használtat kellesz hozzá beleprogramoznia ! - ami hamar meg lesz, és kis munkából jön majd ki .

Ha többet akarsz róla tudni, akkor kattints ide !

» a ⚽ művelet :

[ Szerkesztve ]

Az algebrát a nyugati matematikusok vízszintesen írják . A távol-keleten eredetileg függőlegesen írtak szövegeket . Ha ezt a távol-keleti függőleges írást a nyugati algebrára alkalmazzuk, akkor egy egészen másik elképesztő világa tárul fel az algebrának ! Természetesen készítettem hozzá programot is .


Ez a weblapja, ill. honlapja :
https://erdosattilask01.lapunk.hu/a-fuggoleges-algebra-1213911


, és innen töltheted le erről a weblapról a webes .js programját :
https://erdosattilask01.lapunk.hu/a-fuggoleges-algebra-1213911#letöltés


"
» bevezető :
A vízszintes algebrában a műveleteit és értékeit vízszintesen soroljuk fel . A függőleges algebrában a műveleteit és értékeit függőlegesen soroljuk fel . A kortárs programozásban alkalmazott vízszintes algebrában a stringeket magyarul karakterláncokat idézőjeleket határoljuk, vagyis kezdjük és zárjuk le . Az én új programozásomban alkalmazott függőleges algebrámban a stringjeimet nem határoljuk se idézőjelekkel se más jelekkel .


A vízszintes algebrában a stringeket a hagyományos & társulás jellel fűzzük össze, ellenben a függőleges algebrámban a stringeket a ₰ villás társulásjellel fűzzük össze .


például:


"abcd" & "efgh" & "ijkl"
<=>
abcd
₰
efgh
₰
ijkl


-.-
abcdefghijkl



Továbbá a vízszintes algebrában a műveleteinek funkcióját nem írjuk ki, ellenben a függőleges algebrámban a függőleges algebra műveleteinek funkcióját kiírjuk . Pontosabban ha akarjuk, akkor kiírjuk, ha meg nem akarjuk kiírni, akkor a forráskódjában is elrejthetjük .


A függőleges algebrámban a kiírt forráskód textjét és a szintén kiírt függőleges algebra kód textjét a fordított társulásjellel ⅋ fűzzük össze . Ez a weblapom nem tudja megjeleníteni ezt a " ⅋ &#8523; " karaktert, de ez senkit ne zavarjon, mert ha más nem, akkor a " Segoe UI Symbol " betűtípus biztosan megtudj jeleníteni nektek is !
"

A matematika leprogramozásához tudomásul kell venni, hogy maga a ChatBot is tulajdonképen egy matematika !

https://erdosattilask01.lapunk.hu/csaladi-chatbot-alap-1213918
A családi ChatBot egyszerű alapja !

Tulajdonképen nektek, majd az ezt követők lesznek érdekesebbek !

https://erdosattilask01.lapunk.hu/plankalkul-tematikus-html-kialakitas-1213920
Plankalkül tematikus HTML kialakítás !

benne váltakozik a vízszintes és a függőleges írás

[ Szerkesztve ]

Matematikai alapokra helyeztem a ChatBot féle lekérdezést !
Ha e lekérdezést segéd jelekkel látjuk el, akkor egy algebra körvonalazódik ki előttünk !

Többek között arra lennék kíváncsi, hogy szerintetek: Mit tehetnék még érte ?

https://erdosattilask01.lapunk.hu/csaladi-chatbot-algebra-1213922
A családi ChatBot komplikált algebrája !

Még nincs hozzá letölthető web-program, csak a részletekbe menő leírása van fent, de napokon belül elkészítem nektek, és működni is fog ♥

Ez első változaton egy picit javiatanom kellett, jobb lett amaz is, le is tölthetitek azt a javitot változatot .

[ Szerkesztve ]

+
kicsi jobb lett a bevezetője, pár minta is lett hozzá .
https://erdosattilask01.lapunk.hu/csaladi-chatbot-algebra-1213922

Meglett amit akartam, de még nyers !

Egy picit még meg kell piszkálnom és meg kell írnom a dokumentációját a portálomra, és máris le is tölthetitek majd akkor .

Sajnos a "testi valóm" tiltakozik az időjárás és a bútoraim régi volta miatt, remélem nem fog a testem addig hardver hibázni !

https://erdosattilask01.lapunk.hu/csaladi-chatbot-algebra-1213922
2. A családi ChatBot komplikált algebrája !

Most már teljesen készen van, és le is töltető e web-programom ! ♥

E ChatBot operátorait egy szériába fejtetem, ezért emiatt is érdekesebb .

És nem került milliókba, pár konzerv és üdítőital árából meg lett .

[ Szerkesztve ]

https://erdosattilask01.lapunk.hu/a-morphius-studim-1213934

A Lolita programnyelvem univerzumának alapvető stúdiója !
> röviden mondva csak <
Morphius Stúdió !
> Hogyan készítsünk saját Morphius() függvényeket ? <

=> sikerült az összes eddigi Morphius*() web-program lapjaimat 1 db weblapra bedolgoznom !

Ez lesz az alapja a Lolita programnyelvemnek is, ezért azokat akiket az új programnyelvek izgatják, nem hagyhatják ki !

Ez még csak egy menükezelő programocska, aminek az egyik menüje épen e Lolita programnyelvem is lesz !

Hanem e Lolita prg-ny. a matematikai formalizmusok feldolgozására remekül használható lesz, mert a tokenek általános feldolgozására készítettem ♥

Addig is gyakoroljátok be magatokat e Morphius Stúdiómba, nem is nehéz és szórakoztató is !

UFO + OOP
A Földönkívüliek programnyelve !
Az objektumelvű függőleges algebrám !

Az ad hoc tudományok polcáról !
https://erdosattilask01.lapunk.hu/ufo--oop-1213992

Akik követik az írásaimat, azok tudják hogy sok furcsa tanulmányt írtam nektek . Csak hogy evvel rengeteg még le nem írt írni valóm is felhalmozódott .

Mivel egyikőtök sem jelentkezett asszisztensemnek, ezért most muszáj rövidnek lennem . Ez az objektumorientált függőleges programnyelv tervezetem, a volt függőleges algebrám nem várt kiterjesztése .

Milyen is a függőleges algebrám ?
A függőleges algebrámat úgy képzeld el, hogy a vízszintes algebra szóközeit a soremelés karakterre cseréled le, és messzemenően támogatva van az eval() függvény .

A részleteit itt láthatod ! De a továbbiak megértéséhez nem kell újra elolvasnod a függőleges algebra tanulmányomat ! Az objektumorientált programozásról elképesztő mennyiségű irodalom van az interneten .

a továbbiakat lásd a fenti linkemen ♥

Helyzetjelentés a végekről :

A Lolita prg-ny. megint megtréfált: jól alakul, ill. alakult, de megint talán újra kellesz szabnom az egészet ! Nem mondanám, hogy az egész szénakazalt, mert elégé jól rendezett már, csak még jobbra akarom csinálni !

Nem arról lenne szó, hogy a továbbiakat kellesz újszerűbben, hanem visszamenőleg az eddigieket is újra kell "szabésznem" !

Mivel mindennek csak egészen a kezdetén vagyok, még nem tudhatom, hogy meddig jutok evvel az újabb Lolita verzióval ;ha esetleg tévedés lenne ez a vonala, akkor visszatérek a régebbihez !

Most hosszabb ideig szüneteltem vele, mert megjelent a ChatGPT is, és egy stúdiót is félig megcsináltam, aminek a töredéke lenne e volt Lolita prg-ny.-em ! Nem hinném, hogy egy héten belül komolyabb eredményre jutnák vele, azért sem mert gyenge az általános motivációs hangulatom nem csak Lolita kapcsán !

+ ma éjszaka: hétfő 2024.3.12.
Sikerült startolnom ezt az új verziót, szépen összejött, biztató, de inkább nem ígérek időpontokat !

Ezt sikerült kiszámoltatnom vele:
12 + 23 + 34 * 45 * 5.6 ^ 6.7 ^ 7.8 / 910 / 1011 - 1012 - 1013

=
2.0951020135758248e+36
, de nem ez volt a cél, hanem a startolása !