Revision 55 Version 12

1. Numbers using underscore _

? 0x6000_0000_0000_0000&& ' long long 64bit
? 9_223_372_036_854_775_807&& ' max long long
? 0x0000_0000& ' long 32 bit
? 2_147_483_647& ' max long
? 0x0000% ' integer 16bit
? 32_767% ' max integer
? 0x00ub ' byte 8bit unsigned only (0 to 255)
? 2_55ub ' max byte
? 0x8000_0000_0000_0000 ' decimal type (hold values as unsigned long long)
? 18_446_744_073_709_551_615@ ' max usnigned long long (decimal type)
? 123_456_789.876_543_210@ ' decimal type 27 digits
? #FFFFFF, #FFFF00=-65535 ' HTML COLORS - NO underscore
? 46_000ud=date("9/12/2025")
Def t(x)=type$(x)
? t(12_456.123_4#)="Currency"
? t(1_012.232e-10~)="Single"

2. Structures. New type Currency. When we use offset without label (here c) now interpreter pick the first one here the c.

2.1 Using only offest

structure alfa {
    c as currency
}
buffer mem as alfa*100
? len(mem)
return mem, 3:=123121.2345#
z=eval(mem, 3)
? type$(z)="Currency", z=123121.2345#

2.2 Casting Currency to byte offsets

buffer mem as byte*1000
? len(mem)
return mem, 0:=123121.2345 as currency
z=eval(mem, 0 as currency)
? type$(z), z

2.3 Casting from long long to currency (123.4567 they have the same bits but rendering with the last 4 digits as fractional part)

buffer clear mem as byte*1000
Return mem, 100:=1234567 as long long
? eval(mem, 100 as Currency)

2.4 Long Long have also a bug and that bug removed

structure cc {
    d as integer*10
    c as long long ' usigned long long (8 bytes)
}
buffer clear mem as cc*100
a=0xFFFF_FFFF_FFFF_FFFF
' unsigned long long are Decimal types
Print type$(a)="Decimal"
' but we fit it on 8 bytes (the first 64bit)
return mem, 10!c:=0xFFFF_FFFF_FFFF_FFFF, 4!d!9:=65535
z=eval(mem, 10!c)
Print type$(z)="Decimal", z=18446744073709551615@
k=sint(z) 'same bits as long long (signed) )is the number -1
Print type$(k)="Long Long", k=-1 ' so k is long long signed
b=eval(mem, 4!d!9)
? b, type$(b)="Currency" ' this is the unsigned type for long and integer
integer b1=sint(b, 2)
? b1=-1, type$(b1)="Integer"

2.5 A bigger example with structure (Buffers can be put/get using files) 

module check3 {
    structure compount {
        s as integer*19 ' for string
        st as integer ' for end point
        c as currency
        q as currency
    }
    buffer clear mem as compount*10
    put(mem, 4,"Mc Donuts", 1.233#, 12)
    put(mem, 5,"Hellios", 123.789#, 100.5)
    open "saveme.dat" for output as #f
    put #f, mem, 1
    close #f
    // narrow our buffer
    buffer clear mem as compount*2
    open "saveme.dat" for input as #f
        get #f, mem, len(compount)*4+1
    close #f
    show(mem, 0)
    show(mem, 1)
    sub put(m, a, n as string, am as currency, qu as currency)
        Return m, a!s:=n, a!st:=0, a!c:=am, a!q:=qu
    end sub
    sub show(m, a)
        Print "Name:";LeftPart$(Eval$(m, a!s, 40), chr$(0)),
        Print @(20),"Amount:";eval(m, a!c),@(40),
        Print "Items:";eval(m, a!q)
    end sub
}
check3

Complex Numbers

This is a class fot complex numbers. Here is the export. We get power of complex, with various combinations. I use Atan2 from internal math library (atach on Math object). To prevent π to write as π (greek letter) and not p (windows subtitute π to p) we use  Wide Output (UTF16LE).

Output:

(1+i)^5=(-4-4i)
(2+2i)^6=(-512i)
(1+i)^18=(512i)
(2+i)^(3-i)=(14.8073788312+9.8335865958i)
(221-4i)^(12+3i)=(-1.38398760508149E+28-3.82799320957046E+27i)
e^(πi)+1 = (0)

module check (filename as string=""){
	Class Complex {
	private:	
		double vr, vi
	public:	
		function Arg {
			declare m math
			Method m, "Atan2", .vi, .vr as ret
			=ret
		}
		final pidivby180=1.74532925199433E-02
		final m_e=2.71828182845905
		final maxval=1.7976931348623157E+308
		property real {
			value {link parent vr to vr : value=vr}
		}
		property imaginary {
			value {link parent vi to vi : value=vi}
		}
		property toString {
			value { clear 'so a new clear as string created after
				link parent vr, vi to vr, vi
				if vi then
					if vr then
						if vi>0 then
							if vi==1 then value="("+vr+"+i)" else value="("+vr+"+"+vi+"i)"
						else
							if vi==-1 then value="("+vr+"-i)" else value="("+vr+""+vi+"i)"
						end if
					else
						if vi=1 then value="(i)" else.if vi=-1 then value="(-i)" else value="("+vi+"i)"
					end if
				else
					value="("+vr+")"
				end if
			}
		}
	
		function exp(rr=10) {
	            double exp = .m_e^.vr
	            c=this
	            th=.vi/.pidivby180
	            c.vr<=round(exp * cos(th), rr)
	            c.vi<=round(exp * sin(th),rr)
	            =c
	       }
		function cabs() { ' ret type double
			if abs(.vr)=infinity or abs(.vi)=infinity then =.maxval:Exit
			double c=abs(.vr), d=abs(.vi)
			if c>d then
				r=d/c
				=c*sqrt(1+r*r)
			else.if d==0 then
				=c
			else
				r=c/d
				=d*sqrt(1+r*r)
			end if
		}
		function clog {
			c=this
			c.vr<=ln(.cabs())
			c.vi<=.Arg()
			=c
		}
		function pow() {
			if match("G") then
				read p as Complex
			else
				read p1 as double
				p=this:p.vr=p1:p.vi=0
			end if
			Read ? rr=10
			exp=.clog()*p
			c=exp.exp(rr)
			c.vr=round(c.vr, rr)
			c.vi=round(c.vi, rr)
			=c
	       }	
		function conj {
			c=this : c.vi-! : =c
		}
		function absc {
			c=this*.conj() : =sqrt(c.vr)
		}
		operator "+" {
			read k as Complex : .vr+= k.vr : 	.vi+= k.vi
		}
		operator "-" {
			read k as Complex : .vr-= k.vr : .vi-= k.vi
		}
		operator "*" {
			read k as Complex
			double ivr = .vr*k.vr-.vi*k.vi
			.vi <= .vi*k.vr+.vr*k.vi
			.vr <= ivr
		}
		operator "/" {
			read k as Complex
			k1=k*k.conj()
			acb = this*k.conj()
			.vr <= acb.vr/k1.vr
			.vi <= acb.vi/k1.vr
		}
	class:
		module Complex (.vr, .vi) {}	
	}
	open filename for wide output as #f
	r=Complex(1,1)
	rr=r.pow(5)
	Print #f, r.toString+"^5="+rr.toString
	r=Complex(2,2)
	rr=r.pow(6)
	Print #f,  r.toString+"^6="+ rr.toString
	r=Complex(1, 1)
	rr=r.pow(18)
	Print #f, r.toString+"^18="+rr.toString
	z=complex(2,1)
	b=complex(3, -1)
	r=z.pow(b)
	Print #f, z.toString+"^"+b.toString+"="+r.toString
	z=complex(221, -4)
	b=complex(12, 3)
	r=z.pow(b)
	Print #f, z.toString+"^"+b.tostring+"="+r.toString
	r=Complex(2.71828182845905)
	b=Complex(0, pi)
	z=r.pow(b)+complex(1)
	Print #f, "e^(πi)+1 = "+z.toString
	close #f
}
check "out.txt"
win "notepad", dir$+"out.txt"

Περί της BASIC και της M2000 στην Εκπαίδευση.

To 2020  στη CIE2020 παρουσίασα το Προγραμματιστικό Περιβάλλον της Μ2000 στη Πρωτοβάθμια και Δευτεροβάθμια εκπαίδευση.

Προς το παρόν, Δεκέμβριος 2024, δεν γνωρίζω κάποιο σχολείο να έχει χρησιμοποιήσει τη γλώσσα Μ2000. Τι τρέχει με τους καθηητές πρωτοβάθμιας και δευτεροβάθμιας εκπαίδευσης; 

Δυστυχώς στο σχολείο έχει περάσει η ιδέα ότι τις γλώσσες προγραμματισμού τις χρησιμοποιούμε στο μάθημα της πληροφορικής. Αυτή είναι μια κακή ιδέα. Ας δούμε την ισιορία των υπολογιστών και των περιβάλλοντων προγραμματισμού, που άλλαξαν  τις αντιλήψεις (αλλά όχι στην Ελλάδα).

Στο πανεπιστήμιο του Dartmouth στις ΗΠΑ, ένας καθηγητής και μετέπειτα πρόεδρος του πανεπιστημίου, ο μαθηματικός John G. Kemeny, Ούγγρος μετανάστης στις ΗΠΑ,  αποφάσισε κάτι για το οποίο μέχρι τότε ήταν αδιανόητο: Να μπορούν οι προπτυχιακοί φοιτητές να χρησιμοποιούν ελεύθερα (για οποιαδήποτε χρήση) υπολογιστή του πανεπιστημίου (αυτό δεν φαντάζει κάτι δύσκολο τώρα αλλά όχι τότε).

Μέχρι να μπει η ιδέα του σε κίνηση, όλοι οι υπολογιστές παγκοσμίως ήταν για ειδικούς. Και αυτό γιατί ένας υπολογιστής ήταν ένα πράγμα σε όγκο δωματιών αν όχι δωματίου, και εκτελούσε ένα πρόγραμμα κάθε φορά! Ποιος θα ήταν ο τυχερός να τρέξει το πρόγραμμά του; Σίγουρα λίγοι είχαν το δικαίωμα να "τρέξουν" κάτι. Μάλιστα για να τρέξει το πρόγραμμα έπαιρνε σειρά, ανάμεσα σε άλλα που μπορεί να ήθελαν μέρες για εκτέλεση! Έτσι αν υπήρχε λάθος, γίνονταν αλλαγές και πάλι αναμονή ημερών για να δουν αν τελικά θα βγει κάτι! Τα προγράμματα γράφονταν στο χέρι και δίνονταν σε ενα χειριστή καρτών για να παράξει τις κάρτες (punch cards) που δίνονταν για πέρασμα του προγράμματος για εκτέλεση. Αυτά γίνονταν με γλώσσες προγραμματισμού όπως Fortran, Cobol , ALGOL, καθώς και Asssembly.

Το πρώτο πράγμα που έκανε στο Dartmouth ο καθηγητής ήταν να βρει το κατάλληλο εργαλείο (hardware), το οποίο φυσικά δεν είχε το λογισμικό που θα ήθελε, αλλά θα μπορούσε να γραφτεί.  Η ιδέα του Time Sharing ανήκει σε έναν συνεργάτη του, αλλά σημασία έχει ότι στο πανεπιστήμιο αυτό γράφτηκε το πρώτο σύστημα διαμοιρασμού χρόνου επεξεργασίας προγραμμάτων. Τα προγράμματα έτρεχαν "ταυτόχρονα" κατά την άποψη των χρηστών - των προπτυχιακών φοιτητών. Κατά το σύστημα, τα προγράμματα έτρεχαν σε διαδοχικά "μοιράσματα" του επεξεργαστή με συνέπεια τα προγράμματα να τελειώνουν σαν να έτρεχαν "παράλληλα". 

Το δεύτερο πράγμα λοιπόν ήταν το DTSS (Dartmouth Time-Sharing System) από το οποίο πέρασε και σε όλο το κόσμο. Ο σπουδαστής έγραφε σε ένα τερματικό (όχι με κάρτες πια), απομακρυσμένα, δεν έβλεπε ποτέ τον υπολογιστή! Επίσης δεν υπήρχε οθόνη, αλλά εκτυπωτής (teleprinter) που έρχονταν και η απάντηση από τον υπολογιστή (δεκαετία του 1960)! Ο υπολογιστής στοίχιζε $4.2 εκατομμύρια (δολάρια σε τιμές του 2022), το τερματικό ήταν σαφώς "μηδαμινής" αξίας. Ο εκτυπωτής μοντέλο 33 (1963) είχε το σύστημα συμβόλων ASCII  αυτό που επικράτησε και στους μικροϋπολογιστές και στα PC, και ακόμα και σήμερα το A το αγγλικό έχει το νούμερο 65 όπως στο ASCII, και όλα τα αγγλικά γράμματα έχουν το ίδιο νούμερο σε όλα τα συστήματα κωδικοποίησης γραμμάτων των υπολογιστών, που φτιάχτηκαν μετά το ASCII!

Πώς βρέθηκαν τα λεφτά για τον υπολογιστή; Ο Καθηγητής Kemeny ήταν τόσο καλός που πήρε βραβείο το 1959 από το Alfred P. Sloan Foundation, με σκοπό να φτιαχτεί ένα νέο τμήμα! Έτσι ξεκίνησε να ψάχνει και για τον υπολογιστή αλλά και για τους συνεργάτες του νέου τμήματος

Η γλώσσα που γράφτηκε για τους φοιτητές θα έπρεπε να ήθελε το λιγότερο δυνατό χρόνο εκμάθησης. που εν τέλει ήταν τρεις ώρες. Ακριβώς τρεις ώρες χρειάζονταν για να μάθει κανείς τις εντολές τις BASIC. Αν έβαζαν την FORTRAN θα χρειάζονταν τουλάχιστον μια βδομάδα και αυτό θεωρήθηκε υπερβολικό και κάτι που θα έδιωχνε τους πιθανούς χρήστες μιας πιο εύκολης γλώσσας. Επίσης είχαν φτάσει σε σημείο να έχουν έναν compiler (μεταφραστή προγράμματος σε γλώσσα μηχανής) για ALGOL 30 που μπορούσε να δώσει πρόγραμμα πολύ γρήγορα (με το πέρασμα και της τελευταίας κάρτας). Και πάλι όμως ήθελαν κάτι πιο απλό, και ξεκίνησαν το πρόγραμμα DOPE (Dartmouth Oversimplified Programming Experiment), το οποίο έβαλε αριθμούς γραμμών στις εντολές! Για ένα εξάμηνο εξετάστηκε με μια ομάδα φοιτητών, και θεωρήθηκε σωστό βήμα και έτσι προέκυψε η BASIC.

Ο καθηγητής Kemeny είχε πει για την BASIC :

“Το όραμά μας ήταν ότι κάθε φοιτητής στην πανεπιστημιούπολη θα πρέπει να έχει πρόσβαση σε έναν υπολογιστή και κάθε μέλος ΔΕΠ θα πρέπει να μπορεί να χρησιμοποιεί έναν υπολογιστή στην τάξη όποτε είναι απαραίτητο. Ήταν τόσο απλό.”

Οι φοιτητές χρησιμοποιούσαν τη γλώσσα BASIC για να κάνουν υπολογισμούς πάνω σε δεδομένα, δεν έφτιαχναν κάποιον ειδικό αλγόριθμο όπως για παράδειγμα της ταξινόμησης. Προφανώς αν ήθελαν ταξινόμηση θα έβρισκαν από κάπου έναν αλγόριθμο και θα τον έβαζαν στο πρόγραμμά τους. Το πρόγραμμα δηλαδή είναι ένα εργαλείο που ρυθμίζει τον υπολογιστή για το πώς θα επεξαργαστεί κάποια δεδομένα, ή με άλλη σύνταξη πρότασης ο σπουδαστής επεξεργάζεται στοιχεία με πρόγραμμα που συντάσει σε μια γλώσσα και τα προωθεί (στοιχεία και πρόγραμμα) στο περιβάλλον εκτέλεσης, τον υπολογιστή.

Την εποχή που σπούδαζα, 1985-1989, η Basic ήταν η βασική γλώσσα. Βέβαια κανείς καθηγητής δεν ζήτησε να δουλέψουμε για το δικό του μάθημα με υπολογιστή. Ίσως ήμουν από τους ελάχιστους σπουδαστές που στην πτυχιακή παρέδωσε πρόγραμμα (Επεξεργαστής Στοιχείων), για τη συλλογή και επεξεργασία στοιχείων με εκτυπωσεις πινάκων και ιστογράμματα, γραμμένο σε BBC BASIC σε 32kbyte μηχάνημα με 2 floppy disk  5 1/4'' των 100kb σε κάθε πλευρά - έπρεπε να βγάλει κανείς το δίσκο και να τον βάλει ανάποδα, για να βρει τα άλλα 100kbyte. Το πρόγραμμα για να τρέξει έπρεπε να το σπάσω σε μέρη, και μέσα από ένα drop down menu (τα είχα φτιάξει να δουλεύουν με τα πλήκτρα) ανάλογα με την επιλογή γίνονταν αν χρειάζονταν κατέβασμα από το δίσκο, ως επικάλυψη (overlay) πάνω στo κώδικα  του προγράμματος, σε καθορισμένο σημείο για να μην χαλάει την συνδεδεδμένη λίστα των εντολών του προγράμματος. Για να βρω μνήμη, έπρεπε να αναπρογραμματίσω το 6845 τσιπάκι CRT Controler, για να λιγοστέψω τις γραμμές και να τις κεντράρω, κερδίζοντας 2kbyte ram. Το αρχείο στοιχείων ήταν δυαδικό, (γράφονταν από το δίσκο απευθείας στη μνήμη με μια ανάγνωση) και ήταν με ακέραιους αριθμούς (ενώ εμφανίζονταν ως πραγματικοί με σταθερή υποδιαστολή, πχ στη τέταρτη θέση με τρία δεκαδικά, δηλαδή το 1005 αντιστοιχούσε στο 1,005 τη μονάδα) με πέντε χιλιοστά). Οι ακέραιοι ήθελαν 4bytes, ενώ οι πραγματικοί ήθελαν 5 (40bit πραγματικοί). Αυτοί οι πραγματικοί ήταν καλύτεροι από τους σημερινούς single των 4 bytes, αλλά χειρότεροι από τους double των 8byte που χειρίζεται και ο μαθηματικός συνεπεξεργαστής της κεντρικής μονάδας, ή |CPU. Όμως με τους ακέραιους είδα και το πρόβλημα των πραγματικών, δηλαδή καταχωρόντας έναν δεκαδικό μπορεί να αλλάξουν τα δεκαδικά του από αυτά που βλέπουμε κατά την καταχώρηση. Οπότε έφτιαξα μια δική μου ρουτίνα εισαγωγής για σταθερή υποδιαστολή (έτσι δεν έπαιρνα πραγματικό αλλά ακέραιο, σε χαρακτήρες, όπου η μετατροπή σε δυαδικό δεν είχε πρόβλημα).

Επειδή έκανα πρακτική και πτυχιακή στη σχολή, δηλαδή με πλήρωναν για έξι μήνες εργασία, μου έδωσαν και άλλα προγράμματα ως παραγγελία όπως ένα για Γραμμική Παλινδρόμηση (όρος στατιστικής), ή στα αγγλικά Linear Regression Analysis, όπου για ένα σύνολο Χ και Υ στοιχείων το πρόγραμμα φτιάχνει ένα διάγραμμα και εμφανίζει τα σημεία (Xi, Yi) και μια ευθεία που διέρχεται από τα σημεία όπως προκύπτει από την ανάλυση, παρουσιάζοντας τις σταθερές του "μοντέλου" της ευθείας, b και c, όπου f(x)=y, f(x)=x*b+c.  Δεν έχω σπουδάσει πληροφορική, είμαι αυτοδίδακτος (υπάρχει και αυτό...). Στη σχολή τα προγράμματα που έβαζαν ήταν για "νήπια" και όχι για προχωρημένους όπως εγώ (επειδή είχα υπολογιστή και το χόμπυ μου ήταν να αγοράζω βιβλία και να μεταγράφω προγράμματα στο δικό μου υπολογιστή κάνοντας διάφορες αλλαγές). Μάθαινα δηλαδή γράφοντας αυτά που έχουν γράψει άλλοι και δοκιμάζοντας ιδέες!

Πώς έγινε τώρα και εξαφανίστηκε η BASIC; Η Basic μετά την επινόηση και την εισαγωγή της στην εκπαίδευση από το Dartmouth, δεν έγινε πατέντα, δηλαδή μπορούσε οποιοσδήποτε να γράψει το δικό του μεταφραστή (compiler, εκτέλεση σε κώδικα μηχανής) ή διερμηνευτή (interpreter, εκτέλεση ως έχει). Μια από τις εταιρείες που έφτιαξαν σε 4kbyte μνήμη διερμηνευτή της BASIC ήταν η Microsoft. Η γλώσσα που συνέγραψαν οι ιδρυτές της Microsoft,, το 1975, ήταν η Altair Basic των 4kbyte μνήμης χωρίς χρήση αλφαριθμητικών αλλά με χρήση 32bit πραγματικών (floating point), Είχε τις παρακάτω εντολές:

LIST, NEW, PRINT, INPUT, IF...THEN, FOR...NEXT, SQR, RND, SIN, LET, USR, DATA, READ, REM, CLEAR, STOP, TAB, RESTORE, ABS, END, INT, RETURN, STEP, GOTO, and GOSUB

Η γλώσσα γράφτηκε σε εξομοιωτή του 8080 σε μεγάλο υπολογιστή PDP-10 το πρόγραμμα έβγαινε σε τρυπιτή χαρτοταινία για τον Altair 8800. Σημειώστε ότι και αυτός ο υπολογιστής χρειάζονταν έναν teleprinter, διαφορετικά είχε κάποιους διακόπτεε και λαμπάκια (δεν υπήρχαν led εκείνη την εποχή). Επίσης οι μεταβλητές μπορούσαν να έχουν ένα από τα 26 γράμματα και το πολύ έναν αριθμό από 0 έως 9, δηλαδή το πολύ 286 μεταβλητές. 

Στα 8kbyte μπήκαν και τα αλφαριθμητικά (οι μςταβλητές είχαν το $ στο τέλος του ονόματος) και συναρτήσεις για αλφαριθμητικά. Σημειώστε ότι η ΓΛΩΣΣΑ που μαθαίνουν τα παιδιά του Λυκείου στην Ελλάδα το 2024 δεν έχει συναρτήσεις αλφαριθμητικών (δεν τις έχουν βρει ακόμα χρήσιμες). Ψάξτε εδώ να βρείτε...

Στα 12Kbyte ήρθε η  Extended BASIC, μπηκε το IF THEN ELSE (είχε και το αλλιώς δηλαδή), με 16bit ακέραιους (είχαν το %), signle (πραγματικοί με 32bit) και double (πραγματικοί με 64bit).

O BBC Model B, που δούλευα στη σχολή είχε 16Kbyte για τη γλώσσα και 16Kbyte για το λειτουργικό σύστημα, και 32 kbyte Ram, δηλαδή σύνολο 64Kbyte, όσο και η μέγιστη μνήμη για τη CPU (MOS 6502 8bit). Στη σχολή υπήρχαν XT και AT υπολογιστές IBM, αλλά δεν είχαν μια γλώσσα για να εμφανίζει γραφικά (και δεν είχαν κάρτα γραφικών, για bitmap γραφικά, δηλαδή να σχεδιάζει κανείς, ενώ ο BBC είχε γραφικά, μπορούσες με εντολές MOVE και DRAW να σχεδιάζεις γραμμές).

Η BBC Basic, είχε το Repeat Until, τiς διαδικασίες χρήστη (Procedures) και τις συναρτήσεις χρήστη (Functions) και μπορούσε κανείς να γράψει πρόγραμμα χωρίς να χρειάζεται αριθμούς γραμμών. Αν και είχε υποχρωτικά για τον διορθωτή, επειδή έπρεπε να δηλώσεις τον αριθμό γραμμής για εισαγωγή γραμμής εντολής ή για αλλαγή γραμμής εντολής. Υπήρχε και η GOTO και η GOSUB για συμβατότητα με την BASIC.

Από το 1990 άλλαξε η κατάσταση και τα 16bit μηχανήματα εξαφάνισαν τα 8bit. Εκείνη την εποχή η Pascal (Turbo Pascal) και η Basic (QuickBasic) χρησιμοποιήθηκαν περισσότερο (οι C και C++ ήταν για λίγους). Από το 1995 με τα Windows 95 εξαφανίστηκαν οι μη "συμβατοί" υπολογιστές με αξιόλογες BASIC οπως GFA Basic (Atari STE και Amiga αλλά και MSDOS και Windows), STOS BASIC (επίσης για Atari και Amiga, προορισμένη για να φτιαχνει κανείς παιχνίδια).

Το 1996 το MS Office πακέτο προγραμμάτων διέθετε αστα προγράμματα Word και Excel μια BASIC για να χειρίζεται κανείς την "αυτοματοποίηση" των προγραμμάτων. Το 1998 ήρθε η Visual Basic 5 και λίγο μετά η 6 και τελείωσε το θέμα των γλωσσών! Υπήρχαν τρεις: Visual Basic, Delphi (συνέχεια της Turbo Pascal), Clipper (γλώσσα και μεταφραστής που χειρίζονταν αρχεία της dBase III).

Κάπου εκεί το 1999 είχα την ιδέα να φτιάξω την Μ2000, μια γλώσσα δωρεάν με δυνατότητες για γραφικά, βάσεις δεδομένων και πολυμέσα (βίντο, ήχος, εικόνες/φωτογραφίες).  Το 2003 ήταν έτοιμη η γλώσσα με όλες τις δυνατότητες, όχι ιδιαίτερα γρήγορη αλλά για να εκτελεί προγράμματα που σχετίζονταν με αυτές τις τρεις δυνατότητες, ήταν πολύ καλή (πχ η περιστροφή εικόνας σε οποιεσδήποτε μοίρες γίνονταν με εσωτερική ρουτίνα σε γλώσσα μηχανής πολύ γρήγορα). Υπήρχουν 32 παίκτες ή players (εικόνες με διάφανα σημεία για να μετακινούνται χωρίς να βρίσκονται όντως στη μνήμη που προβάλλονταν στο φόντο, αλλά σε ξεχωριστά σημεία όπου το λειτουργικό σύστημα τα έβαζε πάνω στο φόντο). Επίσης μπορούμε να φτιάχνουμε διαφάνειες με ποσοστό διαφάνειας (πάνω στο φόντο, είναι τα software sprites). Εκτός από αυτά που αρχικά βάλθηκαν ως στόχος μπήκαν και τα νήματα threads και η εντολή Κάθε η Every (την είχε η STOS BASIC) που εκτελεί ένα μπλοκ κώδικα κάθε Χ msec.

Μετά το 2003 και μέχρι το 2013, είχα παρατήσει τη γλώσσα γιατί νόμιζα ότι επειδή  το περιβάλλον γράφτηκε σε Visual Basic 5 δεν θα μπορέσει να τρέξει σε νεότερα συστήματα. Μπόρεσα όμως να την εντάξω στη Visual Basic 6 και να την αναβαθμίσω σε Unicode (τα αρχεία της γλώσσας gsb -geroge small basic- γράφονται σε UTF8  Unicode τύπο, από ANSI 8bit). Επίσης αναβάθμισα τον διορθωτή της γλώσσας από ένα textbox με μέγιστο 32kbyte κείμενο, σε όσο θέλουμε με δικό μου επεξεργαστή κειμένου! Επειδή ο επεξεργαστή κειμένου βασίστηκε σε ένα στοιχείο ελέγχου χρήστη  (user control) για τις φόρμες της Visual Basic, που το έφτιαξα από το μηδέν, μπόρεσα να του φτιάξω ένα σύστημα χρωματιμού (τo textBox ήταν δίχρωμο, με χρώμα γραμμάτων και φόντου). Αυτό που έφτιαξα "ζωγραφίζει¨" πάνω στον καμβά του στοιχείου όπως θέλω. Έφτιαξα δικά μου textbox, editbox, checkbox, listbox, button και για τις ιδιαίτερες φόρμες της Μ2000, όπως για γραμματοσειρές, για φακέλους, για αρχεία, για χρώματα και για μηνύματα (messagebox) και μικρές εισαγωγές (inputbox). Αναβάθμισα τη γλώσσα για να μπορεί να παίρνει τα γεγονότα από τις φόρμες χρήστη και από τα στοιχεία που βάζει πάνω.  Γενικά αναβαθμίστηκε αρκετά η γλώσσα όταν ο τρόπος εύρεσης μιας εντολής έγινε με συνάρτηση Hash και HashTable. Οπότε τα 500+ αναγνωριστικά Ελληνικά και άλλα τόσα Ελληνικά βρίσκονται σε O(1) χρόνο. Ο χρωματισμός των γραμμών εντολών γίνεται υπερβολικά γρήγορα επειδή αφενός βρίσκει τα ονόματα με πίνακα κατακερματισμού (hash table) και αφετέρου γράφει τα στοιχεία χρώματος σε πίνακα δίπλα από κάθε παράγραφο και ακόμα και αν έχουμε ενεργή την αναδίπλωση παραγράφων το σύστημα βρίσκει σε χρόνο μηδέν το πώς θα χρωματίσει το κείμενο! Στο Editbox το σύστημα χρωματισμού προγραμματίζεται δείτε στο Info τα προγράμματα όπως το MEditor, cs, htmleditor, Γλώσσα που ανοίγουν αντίστοιχα διορθωτές σε παράθυρο για Μ2000 γλώσσα, C Sharp, Html, και τη Γλώσσα του λυκείου).

Εκτός από τα γραφικά  (GUI) μπήκαν και όλα τα σχετικά με το OOP, Έτσι με τη Μ2000 μπορούμε να φτιάξουμε προγράμματα που χρησιμοποιούν αντικείμενα.

Στη τελική έκδοση 12, το $ στα αλφαριθμητικά μπορεί να μην χρησιμοποιηθεί (αν και οι έτοιμες συναρτήσεις αλφαριθμητικών το έχουν, όπως και οι μεταβλητές τυπου έγγραφο, που είναι δομές που χειρίζεται ο διορθωτής κειμένου).

Για τη χρήση αντικειμένων υπάρχει βιβλίο:

 ΑΝΤΙΚΕΙΜΕΝΟΣΤΡΑΦΗΣ ΠΡΟΓΡΑΜΜΑΤΙΣΜΟΣ ΣΤΗ Μ2000

Για το όνομα: χρησιμοποιώ το αντικειμενοστραφής για το προγραμματισμό, ως σύστημα, ως προγραμματιστικό παραδειγμα, είναι κάτι που έχει γίνει, δηλώνει κατάσταση, και αντικειμενοστρεφής για τη διαδικασία του προγραμματισμού του χρήση, είναι κάτι που κάνει, δηλώνει ενέργεια. Γενικά πολλοί το λένε με τον ένα ή τον άλλο τρόπο ενώ κατά τη γώμη μου όταν κάτι ΕΧΕΙ, όπως η Μ2000 είναι αντικειμενοστραφής  προγραμματισμός ενώ όταν κάτι ΕΙΝΑΙ τότε είναι αντικειμενοστρεφής προγραμματισμός, όπως είναι η δουλειά του προγραμματισμού.

Η Μ2000 δεν παράγει ενδιάμεσο κώδικα, ούτε τελικό. Δεν παράγει κάτι άλλο εκτός από το να εκτελεί κώδικα με κλήση συναρτήσεων. Όλο το πρόγραμμα εσωτερικά είναι μια σειρά συνερτήσεεων, για τις οποίες αποφασίζει η πρώτη που εκτελεί το πρόγραμμα! Τελειώνει το πρόγραμμα όταν τελειώσει η πρώτη στην εκτέλεση συνάρτηση. Θα μπορούσε κανείς να πει ότι κάθε εκτέλση θα δώσει το ίδιο αποτέλεσμα; Όχι ακριβώς επειδή κατά την εκτέλεση μπορεί να συμβαίνουν: Το περιβάλλον της Μ2000 όπως ο τύπος των γραμμάτων, ο αριθμός στηλών στην κάθε γραμμή, τα χρώματα, καθώς και τα τυχόν αρχεία που θα χρησιοποιήσει το πρόγραμμα, ή και τις διάφορες άλλες εισαγωγές θα αλλάξουν το αποτέλεσμα του προγράμματος.  Αυτό που θέλουμε όμως από ένα πρόγραμμα είναι να έχει την προβλεπόμενη απόδοση για όλα αυτά που αλλάζουν οποτεδήποτε αλλάζουν! Η δυσκολία στο προγραμματισμού είναι ακριβώς εκεί που πρέπει να δούμε τι μπορεί να αλλάξει και μας αλλάξει την συμπεριφορά του προγράμματος! Απλό παράδειγμα. Αν δεν βάλουμε μια εντολή με το χρώμα γραμμάτων και φόντου όπως το θέλουμε τότε το πρόγραμμα θα τρέξει με ό,τι βρει. Αν βρει μαύρο στα γράμματα και μαύρο στο φόντο δεν θα δούμε τίποτα! Δεν μπορούμε να διαβάσουμε τίποτα, γιατί το πρόγραμμα θα εμφανίζει μαύρα γράμματα σε μαύρο φόντο, άρα τίποτα, όλα θα είναι μαύρα! Το ανάλογο στην οδήγηση είναι να μπεις στο αυτοκίνητο και να κάνεις όπισθεν χωρίς να βλέπεις. Κάποια στιγμή θα πατήσεις κάποιον, ή θα σπάσεις το αυτοκίνητο πάνω σε κάποιο άλλο. Ο προγραμματιστής που μαθαίνει είναι σαν να οδηγεί με τα μάτια κλειστά!

Μπορούμε να μάθουμε προγραμματισμό με μικρά βήματα αλλά όχι αργά. Μικρά και μετά λίγο πιο μεγάλα!

Έχω φτιάξει βιβλίο για να μπει κάποιος στον προγραμματισμό με ενδιαφέρον τρόπο:

Μαθαίνω Προγραμματισμό

Και τα δυο αρχεία pdf που αναφέρθηκαν εδώ περιέχουν και το odt αρχείο, και το βλέπουμε αυτό αν τα ανοίξουμε στο LibreOffice,

Στο αρχείο εγκατάστασης του περιβάλλοντος της Μ2000 υπάρχουν δυο βιβλία, ένα στα αγγλικά και ένα στα Ελληνικά με περισσότερα στοιχεία για τη γλώσσα (προς το παρόν είναι έκδοσης του 2023, αλλά ετοιμάζω πιο νέο).

Υπάρχει ένα wiki στο github:

M2000 wiki

Υπάρχουν 480 αναφορές σε προγράμματα/Task της Μ2000 στο rosettacode.org

M2000 Interpreter at Rosettacode.org

Επίσης υπάρχουν παραδείγματα και εδώ σε αυτό το χώρο:

Εγχειρίδιο της Μ2000 (Τεύχη 1-35)

Τέλος είναι πιο εύκολο να δείξουμε σε ένα παιδί ένα πρόγραμμα τριών γραμμών που μετράει από το ένα μέχρι το δέκα:

Για ι=1 έως 10

	Τύπωσε ι

Επόμενο ι

ανοίγοντας το περιβάλλον, γράφοντας Σ Α, και πατάμε enter θα ανοίξει ο διορθωτής και θα γράψουμε τα παραπάνω (ή θα τα αντιγράψουμε από εδώ) και με Esc γυρνάμε στη γραμμή εντολών και γράφουμε Α και πατάμε enter.

 

Του δείχνουμε πως το σώνουμε:

Σώσε πρώτο

Του δείχνουμε πως καθαρίζουμε:

Αρχή

Τώρα του δείχνουμε πως φορτώνουμε

Φόρτωσε πρώτο

και πως το τρέχουμε

Α

Αν θέλουμε να φτιάξουμε μια παραλλαγή τότε γράφουμε Σ Α πατάμε enter και αντιγράφουμε το πρόγραμμα με ctrl +A και μετά ctrl+C μετά πατάμε Esc και γράφουμε  Σ Α1 και φτιάχνουμε το τμήμα Α1 με επικόλληση με ctrl+V, αλλάζουμε το κώδικα πχ βάζουμε 100 αντί για 10 και πατάμε Εsc

Τώρα από τη γραμμή εντολών πατάμε το  Ctrl+A και αυτόματα σώνουμε όλα τα τμήματα στο όνομα που φορτώσαμε (μας ρωτάει το περιβάλλον αν θέλουμε να γράψουμε πάνω στο παλιό και λέμε ναι). Μετά γράφουμε Α1 και πατάμε enter και τρέχουμε το νέο τμήμα.

Από τη γραμμή εντολών τα Ctrl+M και τα Ctrl+N εμφανίζουν τα τμήματα στη μνήμη και από τα δυο μέρη (μνήμη και δίσκο). (εντολές Τμήματα ? και Τμήματα)

Γράφουμε Τέλος και τερματίζει το περιβάλλον!

Όπως φάνηκε από τα παραπάνω απλές εντολέ Σ (συγγραφή), Αρχή, Σώσε, Φόρτωσε, Τμήματα και Τέλος είναι όσα χρειάζεται κανεις να ξέρει για το περιβάλλον. Οι τόνοι δεν έχουν σημασία, τα μικρά μεγάλα δεν έχουν σημασία (μπορεί να γράψει τις λέξεις με κεφαλαία). Έτσι το παιδί που θα ασχοληθεί δεν θα κουραστεί να γράψει απλές ελληνικές λέξεις!

Η τύπωσε που τυπώνει αριθμούς, γράμματα και αποτελέσματα εκφράσεων μπορεί να γραφτεί με αγγλικό ερωτηματικό ?

Επίσης μπορούμε να φτιάξουμε μεταβλητέε άμεσα στη γραμμή εντολών και με το Λίστα να δούμε τις μεταβλητές και τις τιμές τους!

Μπορούμε να τρέξουμε το τμήμα Α με τη Δοκιμή Α και να πατάμετ Επόμενο σε μια φόρμα που μας δείχνει την εκτέλεση βήμα προς βήμα!

 

Η φόρμα Έλεγχος μπορεί να μεγαλώσει από κάτω δεξιά για να φαίνετα καλύτερα σε άτομα με μειωμένη όραση! 

Η εμφάνιση ΠΕΡΙΒΑΛΛΟΝ Μ2000 μπορεί να φύγει με το Οθόνη , 0  (το κόμμα λέει ότι δεν αλλάζουμε το χρώμα φόντου και το 0 λέει ότι θέλουμε να καθαρίσει από τη πρώτη γραμμή, πηγαίνοντας στη πρώτη γραμμή τη χωριστή οθόνη, δηλαδή δεν θα έχουμε χωριστή οθόνη. Εξ ορισμού έχουμε χωριστή οθόνη και για το λόγο αυτό δεν φεύγουν οι γραμμές που δείχνουν διάφορα για το περιβάλλον, όπως ότι τρέχει σε Windows 11.

Το Οθόνη 0, 0 βάζει το μαύρο για φόντο. Μπορούμε να ρυθμισουμε το περιβάλλον με το Ρυθμίσεις (ή με το ctrl+U από το περιβάλλον). Βλέπουμε τη προεπισκόπηση UNICODE. Η Ansi υπάρχει σε περίπτωση που χρησιμοποιησουμε μια μη Unicode γραμματοσειρά (πράγμα που δεν υπάρχουν σε νέα λειτουργικά, αλλά η Μ2000 τρέχει από XP οπότε σε αυτά μπορεί να βρεθεί κάποια).

Οι ρυθμίσεις δεν έχουν πολλά χρώματα για το φόντο. Αλλά μπορούμε να δώσουμε οποιοδήποτε χρώμα με τη Οθόνη για παράδειγμα με το Χρώμα(255, 255, 255) δίνουμε τιμές στο κόκκινο, πράσινο και μπλε το 255 (βάζουμε τιμές από το 0 έως το 255)., το άσπρο είναι το 255, 255, 255. Τα χρώματα από το 0 έως το 15 είναι τα στανταρ των Windows. Η συνάρτηση Χρώμα() γυρίζει αρνητικό αριθμό (είναι τιμή RGB). To μαύρο και στις δυο περιπτώσεις είναι η τιμή 0.  Υπάρχει και ο τρόπος της Html, πχ το #00FF00 είναι το πράσινο με τιμή 255 (δεκαεξαδικό 0xFF ή &hFF), πρέπει μετά το # να ακολουθουν έξι χαρακτήρες απο 0 έως 9 ή από A έως F ο καθένας.

Η Μ2000 εξάγει στο πρόχειρο το πρόγραμμα και σαν κείμενο και σαν html (με κωδικούς χρωμάτων) και έτσι μπορούμε εδώ να ενσωματώσουμε κώδικα με χρώμα. Αν υπάρχει στο κείμενο το tab τότε το εξάγει σαν html με ειδικό τρόπο ώστε να μην χαθεί το tab. To tab στον διορθωτή αλλάζει με το Σ ! 4  μπαίνει πλάτος 4 χαρακτήρες, ενώ στην εμφάνιση με την εντολή Αναφορά (για κείμενο φορμαρισμένο με πλήρη στοίχιση) με το Αναφορά ! 4 γίνεται 4 χαρακτήρες. Οι στήλες στην Print ή Τύπωσε ή ? αλλάζουνε με διαφορετικό τρόπο, ενώ το TAB εμφανίζεται όπως όλα τα στοιχεία από το 0 έως το 31 με έναν χαρακτήρα που δηλώνει τι είναι, και στο TAB, ειναι το ␉ και έχει τα γράμματα HT που σημαίνει Horizontal Tabulation. Ο χαρακτήρας 7 στο ASCII είναι το BELL, και εμφανίζεται ως ␇ και κάνει ήχο όπως το κουδούνι! Δοκιμάστε το  ? χαρ$(7)  ή και το ? χαρκωδ$(7). Το χαρ$() γυρίζει το ASCII (δουλεύει από 0 έως 255) και το χαρκωδ$() δουλεύει για unicode και μπορεί να γυρίσει 4 bytes, πχ το χαρκωδ$(66615) δίνει αυτό 𐐷 το οποιο ανήκει στα surrogates του UTF16LE όπου με δυο θέσεις χαρακτήρων των 16bit γράφεται ένας χαρακτηρας με αριθμό πάνω από 65535.

Test for 100 threads

M2000 Interpreter can use threads (something like green threads). A thread run at a module level at time intervals. Each thread have own stack of values and may have static variables. All variables/modules/functions of module can be used from a thread. We can't have same name for a local variable and a static variable, but we may have the same name for a static variable for each thread.

This example show how a simple function (which we call using @) can used for making threads (a normal function is like a module, may have own threads, so a normal function can't be used to make threads for the calling module).

Main.task is another thread which finish if no other thread exist. Some time a thread may run after Main.Task exit so we can use Threads Erase to erase any thread. See the Thread Execute statement which we can define static variables and add values (also we can put values to stack of  values using Push or Data statement).

For this example we make 100 threads.

module thread_test {
	cls 0,0
	acc=0
	thr=list
	For i=1 to 100  
		Print i, @NewThread(i, random(1, 5)*100)
	next
	main.task 1000/180 {
		Print "This is an example for Threads"
		Print "Threads "+(len(thr)) ', thr
		refresh
		Print thr
	}
	threads erase
	Print "acc="+acc
	end
	function NewThread(n, time) 
		thread {
			static Z=1
			print xX, Z
			z++
			acc++
			if rnd<.3 then delete thr, xX: thread this erase
		} as x interval time
		thread x execute static xX=x
		Append thr, x
		=x
	end function
}
thread_test

New Revision 54 for Version 12

New release here: https://github.com/M2000Interpreter/Environment/releases

For using the release you have to accept the setup file as not a virus. Because this interpreter is a Visual 6 application most antivirus assume that is a virus. It isn't. The exe is signed by me.

You can download this https://github.com/M2000Interpreter/Environment/blob/main/ca.crt and make it as a trusted root certificate: https://learn.microsoft.com/en-us/skype-sdk/sdn/articles/installing-the-trusted-root-certificate

With the same certificate except the setup exe are signed the M2000.dll and the M2000.exe (the small program which load M2000.dll, the interpreter - it is a com object). The M2000.exe also provides a big stack for interpreter (although can run on standard size 1M, using a big enough we can use more than 3500 calls for recursion for functions, more than 7100 for using Call module/function, and more than 8500 calls for modules (without recursion).

Αναθεώρηση 53, Έκδοση 12

Μετά από καιρό έκανα δυο τρεις αναβαθμίσεις που θα πιάσουν τόπο!

1. Δομή επανάληψης Επανάλαβε ή Επανέλαβε (έχουμε και τα δύο για να μην υπάρχει ζήτημα γραμματικού λάθους). Σημειώστε ότι η Μ2000 γυρνάει τα αναγνωριστικά στα κεφαλαία χωρίς τόνους, εκτός από τις εττικέτες για την ΠΡΟΣ (Goto), Το πρόβλημα στη δομή αυτή ήταν ότι δούλευε με Boolean τιμή, με ένα τρόπο που η VB6 (η γλώσσα υλοποίησης) αν έπαιρνε τιμή πχ 5 έβγαζε το δυαδικό Not (αντιστροφή) με αποτέλεσμα να δίνει μια μη μηδενική τιμή (άρα να είναι αληθής). Όσο στις συγκρίσεις είχαμε πράγματι σύγκριση δεν υπήρχε πρόβλημα. Επειδή η Αν Τότε δουλεύει με την μηδενική τιμή για Ψευδής και τη μη μηδενική για Αληθής, θα έπρεπε να το κάνει και η Επανάλαβε.

Ο κώδικας παρακάτω έχει και το διορθωμένο μέρος και άλλα στοιχεία χρήσιμα για την κατανόηση της γλώσσας!

Τμήμα Δοκιμή1 {
	// σε όλες τις δομές επανάληψης υπάχουν τα Έξοδος, Συνέσισε, Διέκοψε, Ξεκίνα, Προς, Από
	// Έξοδος - τερματίζει άμεσα την επανάληψη
	// Συνέχισε - αφήνει το υπόλοιπο του τμήματος για επανάληψη και πάει για έλεγχο τις επανάληψης
	// Διέκοψε - διακόπτει όλες τις φωλιασμένες δομές μέχρι μια Δες { } να την σταματήσει αλλιώς τερματίζει και το τμήμα ή η συνάρτηση.
	// Ξεκίνα - ξεκινάει πάλι το τμήμα εντός της επανάληψης χωρίς να κάνει έλεγχο.
	// Προς - Δίνουμε αριθμό ή ετικέτα (πρέπει να υπάρχουν εντός του τμήματος). Δεν έχει σχεδιαστεί για να μπαίνει σε άλλες επαναλήψεις
	// Από Μεταβλητής Προς ..λιστα αριθμών ή και ετικετών.
	Α=0
	Επανάλαβε
		Αν ΕνΚομ$<>"" τότε Α=100
	Μέχρι Α
	Τύπωσε "Τέλος η Επανάλαβε Μέχρι, πάτα ξανά ένα κουμπί"
	Επανάλαβε
		Αν ΕνΚομ$<>"" τότε Α=0
	Όσο Α
	Τύπωσε "Τέλος η Επανάλαβε Όσο, πάτα ξανά ένα κουμπί"
	Επανάλαβε
		Αν ΕνΚομ$<>"" τότε 100
	Πάντα
	Τύπωσε "Αυτό δεν θα το δεις"
	100 Τύπωσε "Τέλος η Επανάλαβε Πάντα, πάτα ξανά ένα κουμπί"
	
	Α=10
	
	Ενώ Α
		Αν ΕνΚομ$<>"" τότε Α=0
	Τέλος Ενώ
	
	Τύπωσε "Τέλος η Ενώ, πάτα ξανά ένα κουμπί"
	
}
Τμήμα Δοκιμή2 {
	Μακρύς Α=-100
	
	// Πρόχειρο Uint(Α)  ' Bάζουμε στο πρόχειρο αποτελέσματα για να τα βάλουμε εδώ!
	
	Τύπωσε Όχι Α, Δυαδικό.Όχι(Α)=2147483747, Δυαδικό.Αντι(Α)=99, Α=-100,  Uint(Α)=4294967196
	//  Ψευδες Αληθές Αληθές Αληθές Αληθές
	
	Δεκαεξ Όχι Α, Δυαδικό.Όχι(Α), Δυαδικό.Αντι(Α),  Α, Uint(Α)
	// 0x0000 0x80000063  0000000000000063 0xFFFFFF9C, 00000000FFFFFF9C
	
}
Δοκιμή1
Δοκιμή2

2. Πίνακες με τετράγωνες αγκύλες, εξαγωγή σε αυτόματο πίνακα (tuple) και εισαγωγή από πίνακα με παρενθέσεις ή αυτόματο πίνακα. Οι πίνακες στη Μ2000 είναι εσωτερικά αντικείμενα. Το βασικό αντικείμενο είναι ο mArray (υπάρχει το mArray.cls στο κώδικα της Μ2000). Αυτό το είδος πίνακα χειρίζεται μέχρι 10 διαστάσεις, με διαφορετικά όρια ανά διάσταση. Αρχικά ήταν τύπου Variant (16 Bytes κάθε στοιχείο), αλλά στις νεότερες εκδόσεις παντρεύτηκε με τον RefArray έναν πίνακα που μπορεί να έχει στοιχεία διαφόρων μεγεθών από ένα μέχρι 16 Byte ανάλογα με τον τύπο. Επιπλέον ο RefArray δεν έχει διαστάσεις, παρά μόνο μία. Όμως μπορούμε να έχουμε δεύτερη διάσταση ως πίνακα από RefArray, καθώς και περισσότερες. Δηλαδή ενώ στον κανονικό πίνακα όλα τα ατοχεία είναι σε μια περιοχή μνήμης και από τις διαστάσεις υπολογίζουμε το στοιχείο που θέλουμε να γράψουμε ή να αλλάξουμε, στους RefArray τύπου πίνακες πχ φαινομενικά δυο διαστάσεων το πρώτο νούμερο μας δίνει το στοχείο (μιας διάστασης πίνακα) το οποίο είναι επίσης πίνακας. Έτσι ο RefArray έχει πιο γρήγορη χρήση για το στοιχείο πίνακα, και επιπλέον έχει ανά δείκτη προς πίνακα διαφορετικά μεγέθη πίνακα (πχ μπορούμε να φτιάξουμε τριγωνικό πίνακα). Και στον πίνακα με παρενθέσιες μπορούμε να κάνουμε κάτι τέτοιο αλλά είναι πιο μπερδεμένο (πιο χειροκίνητο). Οι πίνακες και οι αυτόματοι πίνακες μπορεί να είναι μηδενικοί αλλά οι RefArray πρέπει να έχουν ένα στοιχείο. Επίσης ένας RefArray έχει πάντα 0 το πρώτο στοιχείο και αν ορίσουμε Διπλός Α[10] θα έχουμε 11 στοιχεία από 0 έως 10. Επιπλέον ο RefArray μεγαλώνει απλά βάζοντας μεγαλύτερο δείκτη! Ενώ ο πίνακας με παρενθέσεις μεγαλώνει με την Πίνακας και ο αυτόματος πίνακας έχει δικά του κόλπα (έχει συναρτήσεις τύπου #όνομα() που διαδοχικά κάνουν πάνω σε αυτόν πολλά πράγματα, χωρίς να τον πειράζουν),

Στο παράδειγμα παρακάτω βλέπουμε την Πίνακας(α) που αντιγράφει σε αυτόματο πίνακα τον α. Επίσης παρακάτω ο α παίρνει νέα τιμή από ένα ταξινομένο αντίγραφο του α. (δυο λειτουργίες που προστέθηκαν, από και προς αυτόματο πίνακα αντιγραφή).

Επιπλέον αναβαθμίστηκαν οι Πάρε και Δώσε για να λειτουργούν εκτός από Διαρθρώσεις μνήμης και με πίνακες με τετράγωνες αγκύλες. Μπορούμε να μεταφέρουμε όλο ή μέρος σε αρχείο, καθώς επίσης μπορούμε να μεταφέρουμε από το αρχείο σε όλο ή σε μέρος του πίνακα. Εδώ πίνακες με είδος στοιχείου αντικείμενο, αλφαριθμητικό και άτυπο (variant) δεν υποστηρίζονται στις Πάρε και Δώσε.

Είδη πινάκων με αγκύλες:

Διπλός, Απλός (πραγματικοί με ύψωση σε δύναμη, Double, Single)

Αριθμός (27 ψηφία και με κινητή υποδιαστολή, Decimal)

Λογιστικός (σταθερά 4 δεκαδικά, Currency)

Ψηφίο (1 Byte, τιμές από 0 μέχρι 255)

Ακέραιος, Μακρύς, Μακρύς Μακρύς (2, 4, 8 bytes ακέραιοι, Integer, Long, Long Long)

Ημερομηνία (8byte, γράφει μέρα, ώρα ή και τα δύο, οι μέρες είναι το ακέραιο μέρος, η τύπωσε την εμφανίζει ως αλφαριθμητικό)

Γράμμα (4 byte  δείκτης σε Αλφαριθμητικό)

Αντικείμενο (4 byte δείκτης σε αντικείμενο, πχ Σωρός, Λίστα, Αυτόματος Πίνακας, Πίνακας με αγκύλες).

Άτυπος (16 byte, παίρνει οτιδήποτε, Variant)

Μπορούμε να φτιάξουμε ένα πίνακα με ένα από τα είδη και με τους κανονικούς πίνακες. Εδώ φριάχνουμε ένα πίναα δυο διαστάσεων: 

Πίνακας α(-3 έως 7, 1 έως 5) ως Διπλός=1 

Για δυο διαστάσεις φτιάχνουμε και με πίνακα με τετράγωνες αγκύλες:

Διπλός α[10][4]=1 

Τμήμα Περί_Πινάκων {
	Πίνακας α(-3 έως 7, 1 έως 5) ως Διπλός=1
	Τύπωσε α()#αθρ()=55, μήκος(α())=55, Διάσταση(α())=2, Διάσταση(α(),1, 0)=-3
	
	Διπλός α[10][4]=1
	Τύπωσε μήκος(α)=11, μήκος(α[0])=5
	// Τό Τύπωσε Πίνακας(α) βγάζει λάθος, ο α έχει δυο διαστάσεις.
	Τύπωσε Πίνακας(α[0])#αθρ()=5
	Αντικείμενο α1[4]
	// σύνδεση με δείκτη
	α1[2]=α
	α1[2][10][2]=1000
	α1[2][10][2]++
	Τύπωσε α1[2][10][2]=1001
	Βάλε 500 : Διάβασε α1[2][4][1]
	Τύπωσε α1[2][4][1]=500, α[4][1]=500, α[10][2]=1001
	// σύνδεση με αντίγραφο
	α1[1]=α[]
	α1[1][10][2]=3000
	α1[1][10][2]+=100
	Τύπωσε α1[1][10][2]=3100, α[10][2]=1001
	α[10][2]=1234
	Τύπωσε α1[2][10][2]=1234
}
Περί_Πινάκων

 

Τμήμα Δοκιμή3 {

	Διπλός α[10]=4, αθρ
	α[2]=500
	Τύπωσε Στρογγ(Πίνακας(α)#Αθρ()/Μήκος(α), 3)=49.091
	// χρήση επανάληψης
	Για ι=0 έως μήκος(α)-1
		αθρ+=α[ι]
	Επόμενο
	Τύπωσε Στρογγ(αθρ/Μήκος(α),3)=49.091
	// γίνεται αυτόματος πίνακας, γίνεται ταξινόμηση, γυρίζει πάλι ως πίνακας με []
	α=Πίνακας(α)#Ταξινόμηση()
	// 4 4 4 4 4 4 4 4 4 4 500
	Για ι=0 έως μήκος(α)-1
		Τύπωσε α[ι];" ";
	Επόμενο
	Τύπωσε
	
	// παραγωγή δυαδικού αρχείου
	Άνοιξε "Στοιχεία.στ" για εξαγωγή ως #Β
		Δώσε #Β, α, 1
	Κλείσε #Β
	Τύπωσε Αρχείου.Μήκος("Στοιχεία.στ")=8*11
	Διπλός δ[2]=1
	Άνοιξε "Στοιχεία.στ" για εισαγωγή ως #Β
		Πάρε #Β, δ[2], 1+10*8, 8  ' να πάρουμε από το 11 στοιχείο, 8 bytes και να τα ρίξουμε από το δ[2] (που χωράει ένα)
	Κλείσε #Β
	Τύπωσε δ[2]=500
	α[0]=1000
	Άνοιξε "Στοιχεία.στ" για συμπλήρωση αποκλειστικά ως #Β
		Δώσε #Β, α[0], 1+10*8, 8
		Πάρε #Β, δ[2], 1+10*8, 8
		Μετάθεση #Β, 11*8+1
		Δώσε #Β, α
		Δώσε #Β, δ
		' τα αρχεία ξεκινουν από το 1, οπότε πάντα βάζουμε το +1, όταν λογαριάζουμε με βάση το 0 (από πίνακες) 
	Κλείσε #Β
	Τύπωσε δ[2]=1000
	Τύπωσε Αρχείου.Μήκος("Στοιχεία.στ")=8*11+8*3+8*11
}
Δοκιμή3

Καλές Γιορτές!

Γ.Κ.

 

M2000 wiki on GitHub

Look the M2000 wiki on github:   https://github.com/M2000Interpreter/Environment/wiki

I put some images on older and newer programs.