Δευτέρα, 27 Μαρτίου 2017

Αναθεώρηση 5 (Έκδοση 8.6)

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

Δυο παραδείγματα (στα αγγλικά) που δείχνουν την νέα δυνατότητα:
Όταν δημιουργούμε μια κλάση σε ένα τμήμα τότε η κλάση γίνεται αυτόματα μια γενική συνάρτηση. Εντός μιας κλάσης ή μιας ομάδας ο ορισμός κλάσης είναι τοπικός. Όμως επειδή οι ομάδες δεν έχουν ξεχωριστό interface (αλλά ένα κοινό), μπορούμε ένα αντικείμενο να το χειριστούμε αν το δώσουμε ως επιστροφή από μια συνάρτηση. Δηλαδή ο διερμηνευτής της Μ2000 δεν χρειάζεται να ξέρει τι έχει μια ομάδα δηλώνοντας έναν τύπο. Για παράδειγμα όταν δημιουργούμε την Class BetaClass ο διερμηνευτής παίρνει το κείμενο όπως είναι και το καταχωρεί σαν συνάρτηση. Όταν γράφουμε εντός μιας κλάσης ή μιας ομάδας το BetaClass Beta, Delta ο διερμηνευτής εκτελεί αυτό Beta=BetaClass() και αυτό Delta=BetaClass(). Κάθε φορά η συνάρτηση BetaClass() επιστρέφει ένα ανώνυμο αντικείμενο και αυτό έχει μέσα τη λίστα με τα περιεχόμενά του. Ο διερμηνευτής παίρνει τη λίστα και φτιάχνει όλο το περιεχόμενο με το όνομα που δίνουμε εδώ Beta (και μετά με το Delta), έτσι το όνομα της ιδιωτικής k είναι Beta.k αλλά σαν ιδιωτική δεν μπορεί να "βρεθεί" αν την καλέσουμε έξω από ένα τμήμα/συνάρτηση που ανήκει στο Beta. Επειδή και το Beta ανήκει σε μια άλλη κλάση και έχει δηλωθεί ιδιωτικό, ούτε αυτό μπορεί να βρεθεί έξω από εκεί που φτιάχτηκε.
Το Μ θα μπορούσε και αυτό να γύρναγε μια τιμή που θα θέλαμε. Τώρα γυρνάνει ένα αντίγραφο του εαυτού του, δηλαδή ένα αντικείμενο ομάδα με όλα τα στοιχεία του Μ, ακόμα και τα ιδιωτικά ως αντίγραφα. Έτσι μια Ζ=Μ θα παράγει ένα Ζ ίδιο με το Μ (το Ζ είναι αντιγραφή του Μ όχι αναφορά).
Αν το Μ επέστρεφε τιμή (επειδή είχαμε βάλη μια Set { }) τότε το Ζ θα έπαιρνε αυτήν την τιμή. Αν θέλαμε να έπαιρνε το αντίγραφο ομάδας τότε θα το επιστρέφαμε ως Ομάδα(Μ)
Σε περίπτωση που το Μ γύρναγε αλφαριθμητικό τότε θα ήταν γραμμένο ως Μ$ (απαραίτητα πρέπει να φαίνεται στον εκτιμητή παραστάσεων αν κάτι γυρνάει αλφαριθμητικό με το σύμβολο $). Δηλαδή Class Alfa$ { } και M$=Alfa$(). Και από αυτό μπορούμε να πάρουμε την ομάδα με την Ομάδα$(Μ$). Μάλιστα όλες οι ομάδες με όνομα με σύμβολο $ έχουν και όνομα χωρίς αυτό (αλλιώς δεν θα μπορούσαμε να πάρουμε μια αριθμητική τιμή, από μια περιεχόμενη ιδιότητα με αριθμητική τιμή). Στο δεύτερο παράδειγμα κάνουμε χρήση αυτού και έτσι δείχνουμε την τιμή μιας αριθμητικής συνάρτησης της ομάδας Beta$ που φτιάξαμε με την BetaClass$ (και η ομάδα και η κλάση έχουν το σύμβολο του αλφαριθμητικού, σημαίνει ότι η ομάδα και η παραγόμενη από τη κλάση γυρνάει τιμή αλφαριθμητικό)
Όταν δίνουμε τιμές σε ομάδες που περιέχονται σε άλλες, δηλαδή όταν δίνουμε σε ομάδες της ομάδας τότε βάζουμε το <= και όχι το = γιατί ο διερμηνευτής πάντα προτιμάει να φτιάχνει τοπικές μεταβλητές και το "<=" του λέει "ψάξε αλλού" (γενικά το χρησιμοποιούμε για γενικές μεταβλητές, αλλά και για τις μεταβλητές της ομάδας από τις συναρτήσεις και τα τμήματα της ομάδας)

Προσθήκη στο πρώτο παράδειγμα, ο τελεστής "++".


Class Alfa {
Private:
      Class BetaClass {
      Private:
            k=100
      Public:
            Dim B(20)=1234
            Function KLM {=1001}
            Value {=.k}
            Set {Read .k }
            Operator "++" {
                  .k++
            }
            N=130
      }
      \\ make two objects inside Alfa Class
      BetaClass Beta, Delta
Public:
      Module TestMe {
            Print .Beta
            .Beta<=500
            Print .Beta, .Beta.N , .Beta.KLM(), .Beta.B(2)
            Print .Delta, .Delta.N , .Delta.KLM(), .Delta.B(2)
            Print Valid(.Beta.k) \\ 0 = False
            Print .Beta-.Delta \\ 400
            .Beta++
            Print .Beta
      }
}
M=Alfa()
M.TestMe
Print Valid(M.Beta) \\ 0 = False


Σε άλλο τμήμα γράφουμε αυτό:


Class Alfa {
Private:
      Class BetaClass$ {
      Private:
            k$="Yes"
      Public:
            Value {=.k$}
            set {Read .k$}
            Function KLM {=1002}
            Dim B(20)=1234
      }
      BetaClass$ Beta$, Delta$
Public:
      Module TestMe {
            Print .Beta$
            .Beta$<="No"
            Print .Beta$, .Delta$
            Print .Beta.KLM(), .Beta.B(2)
      }
}


M=Alfa()
M.TestMe





Παρασκευή, 24 Μαρτίου 2017

Κράτηση Τμήματος, αλλαγές και συνέχιση!

Η εντολή Δοκιμή ανοίγει τον έλεγχο, όπου μπορούμε να δούμε τιμές, το σωρό, να κάνουμε διάφορα αλλά δεν μπορούμε να αλλάξουμε τιμές. Δεν μπορούμε δηλαδή να διακόψουμε το πρόγραμμα και να επέμβουμε αλλάζοντας τιμές (ίσως κάποτε το βάλω και αυτό).
Μπορούμε όμως με έναν άλλο τρόπο να το κάνουμε! Δηλαδή με το γενικό τμήμα Στάση, γενικό για να το καλούμε απ΄οπουδήποτε, όταν το καλούμε με την Κάλεσε Τοπικά Στάση μας βγάζει σε γραμμή εντολών! Με την Κάλεσε Τοπικά δεν αλλάζει το όνομα του τμήματος. Μπορούμε να αλλάξουμε τιμές (μπορούμε να προσθέσουμε μεταβλητές αλλα θα χαθούν στο πέρας της εκτέλεσης της Στάσης). Μπορούμε να δώσουμε εντολές όπως Λίστα, ή Τμήματα !, αλλά και πιο "βαριές" να δώσουμε τη Σ όνομα_τμήματος και να αλλάξουμε κώδικα, ή να αλλάξουμε θέση ετικετών (όταν αλλάζουμε το κείμενο - πρόγραμμα- του τμήματος σβήνει ο εσωτερικός πίνακας που δείχνει που είναι η θέση της κάθε ετικέτας που ζητήθηκε έστω μια φορά, οπότε ξαναχτίζεται μετά). Γράφουμε την εντολή Συνέχεια, και συνεχίζει το πρόγραμμα! Μπορούμε όσες φορές θέλουμε να βάλουμε το Κάλεσε Τοπικά Στάση. Το ? μόνο του δίνει τη βοήθεια! Αλλιώς είναι το Τύπωσε.




Τμήμα Γενικό Στάση {
      Τοπική αα_$
      Δες {
                  Τύπωσε "Στάση στο "+Τμήμα$+">";
                  Γραμμή Εισαγωγής αα_$
                  Τύπωσε
                  αα_$=Αποκ$(αα_$)
                  Αν αα_$="?" Τότε Αναφορά "Δώσε Συνέχεια για να συνεχίσεις, ή Λίστα, ή όποια άλλη εντολή θέλεις"
                  Αν Κεφ$(αα_$)="ΣΥΝΕΧΕΙΑ" τότε έξοδος
                  Δες οκ {
                        Ένθεση αα_$
                  }
                  Αν Λάθος ή όχι οκ Τότε Τύπωσε Λάθος$
                  Κυκλικα
      }
}
\\ δοκιμή
Τμήμα Κάτι {
      Α=500
      Τμήμα ΚάτιΆλλο {
            Α=10
            Β=20
            Αναφορά {Δοκίμασε σκέτο ?
            επίσης:
                  Λίστα
                  ? Α
                  ? Β
                  Α+=10  ' για αλλαγή τιμής
            }
            Κάλεσε Τοπικά Στάση
            Τύπωσε Α+Β
      }
      ΚάτιΆλλο
}
Κάτι

Αναθεώρηση 4 (έκδοση 8.6)

Σε αυτήν την αναθεώρηση έφτιαξα επιτέλους τις εισαγωγές αριθμών (στην οθόνη και στις φόρμες), να γίνονται βάσει του τοπικού χαρακτήρα δεκαδικών (παλαιότερα ήθελε τη τελεία μόνο).
Το πρόβλημα με την Εισαγωγή (Input) ήταν ότι έπαιρνε δυο ή περισσότερες μεταβλητές και το κόμμα το είχε (και το έχει μαζί με το enter) ως τερματισμός εισαγωγής και ξεκίνημα του επόμενου.
Πώς λοιπόν θα το ξεπερνούσα; Και μάλιστα χωρίς να κάνω πολύ δουλειά;
Το κόλπο λέγεται "ντουμπλάρισμα"...δηλαδή βάζουμε την ρουτίνα να δουλεύει όπως πριν, αλλά εκεί που θέλουμε αλλάζουμε πρόσκαιρα την τελεία με το κόμμα και στην επιστροφή τα αλλάζουμε πάλι!

Η απλή εισαγωγή εισάγει πολλαπλούς αριθμούς με εμφάνιση στην οθόνη με χαρακτήρες σε θέσεις χαρακτήρων (όπως στις παλιές κονσόλες, το ένα γράμμα κάτω από το άλλο).Εισάγει βέβαια και αλφαριθμητικά και αριθμούς "ανάμεικτα"

Π.χ.
Εισαγωγή "Όνομα και ηλικία=", Όνομα$, Ηλικία
μπορούμε μετά το όνομα να πατήσουμε το κόμμα και θα ξεκινήσει η εισαγωγή της ηλικίας (δέχεται μόνο χαρακτήρες για αριθμούς). Στα αλφαριθμητικά δεν δέχεται εισαγωγικά και αγκύλες.
Δουλεύει το ctrl+V το οποίο ουσιαστικά στέλνει τους χαρακτήρες μέσω πληκτρολογίου (κάπου ενδιάμεσα) και έτσι φιλτράρονται. Δεν μπορούμε δηλαδή πονηρά να περάσουμε με επικόλληση χαρακτήρες. Δεν υπάρχει αντιγραφή και αποκοπή στην εισαγωγή αυτού του τύπου. Επιπλέον δεν μπορούμε να πάμε πίσω μερικούς χαρακτήρες χωρίς να σβήσουμε.

Εισαγωγή "(x,y,z)=",x,y,z
Τύπωσε x,y,z

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

Αν θέλουμε να πάρουμε μια γραμμή με οτιδήποτε (γραμμή λέμε αλλά είναι παράγραφος, δηλαδή τερματίζει μόλις πατήσουμε το enter, άρα δεν μπορεί να έχει το enter, χαρακτήρας 13) υπάρχει η Γραμμή Εισαγωγής (δουλεύει και για αρχεία). Εδώ δεν έχουμε αλφαριθμητική σταθερά στην αρχή για να προβληθεί πριν την εισαγωγή. Μια τύπωσε και ο χαρακτήρας ; που δηλώνει να μην φύγει ο δρομέας από την τελευταία θέση, αρκούν.
Τύπωσε "Δώσε κάτι:";
Γραμμή Εισαγωγής α$


Υπάρχουν και άλλοι τρόποι εισαγωγής.Δεν θα τους αναπτύξω όλους εδώ. Απλά όσους "φτιάχτηκαν", σε αυτήν την αναθεώρηση:
Τύπωσε $(4), "Α=";  \\ αναλογική γραφή (από 4 και πάνω, το νούμερο δηλώνει τρόπο)
Εισαγωγή ! Α, 10 \\ καθορίζουμε το πλάτος σε θέσεις χαρακτήρων οθόνης.
Τύπωσε Α
Τύπωσε $(0), "Οκ"  \\ μη αναλογική γραφή, ένας χαρακτήρας σε μια θέση χαρακτήρα οθόνης
Τύπωσε Α


Η εισαγωγή με το θαυμαστικό, έχει δυνατότητα να γράψουμε μεγαλύτερου πλάτους αριθμό. Ουσιαστικά ανοίγει ο διορθωτής σε μια γραμμή και σε πλάτος που δίνουμε και ρυθμίζει την εισαγωγή όπως θέλουμε, μόνο για αριθμούς. Αν χρησιμοποιήσουμε ακέραια μεταβλητή (με το %) τότε δεν θα δέχεται την υποδιαστολή και θα έχει μέχρι 16 το πολύ αριθμούς. Μόλις κλείσει ο διορθωτής (μπορεί να κλείσει και με Esc, αλλά και με άνω και κάτω βελάκι καθώς και με Enter) εξαφανίζεται και ό,τι γράψαμε από την οθόνη (ο διορθωτής είναι στοιχείο πάνω  από την οθόνη). Οπότε τυπώνουμε το αποτέλεσμα.  Εδώ πρέπει να γίνει καθαρό ότι η Μ2000 δεν τυπώνει χαρακτήρες με φόντο μαζί, αλλά πάντα "Διάφανους". Όταν θέλουμε να τυπώσουμε πάνω σε κείμενο, τότε πρέπει να το καθαρίσουμε. Αυτό μπορεί να γίνει ανά γραμμή κατά την ολίσθηση, ή με την εντολή οθόνη να φύγει όλη μαζί.ή να χρησιμοποιήσουμε μια εντολή που δίνει χρώμα γραμμάτων και φόντου για στήλη σε συγκεκριμένη γραμμή, την ~(), ή το παρακάτω:
Τύπωσε @(0,5,πλάτος, 15,5,5),

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

για ι=1 εως 3 {
      Τύπωσε @(0,5,πλάτος, 15,5,5),
      Τύπωσε $(4), "Α=";  \\ αναλογική γραφή (από 4 και πάνω, το νούμερο δηλώνει τρόπο)
      Εισαγωγή ! Α%, 10 \\ καθορίζουμε το πλάτος σε θέσεις χαρακτήρων οθόνης.
      Τύπωσε Α%
      Τύπωσε $(0), "Οκ"  \\ μη αναλογική γραφή, ένας χαρακτήρας σε μια θέση χαρακτήρα οθόνης
      Τύπωσε Α%
      α$=κομ$ \\ πάτα ένα πλήκτρο
}




Η ειδική συνάρτηση της Τύπωσε $() κάνει διάφορα, αν έχουμε αριθμό το πρώτο όρισμα τότε δηλώνουμε το τρόπο εμφάνισης σε στήλες, από το 4 και πάνω είναι με αναλογική γραφή και το 4 σημαίνει ότι τα αλφαριθμητικά στοιχίζονται αριστερά στη στήλη, και αν χρειάζεται παίρνουν και άλλες στήλες, ενώ οι αριθμοί δεξιά., το 5 στοιχίζει όλα αριστερά, το 6 στο κέντρο της στήλης, το 7 δεξιά, το 8 κάνει διπλή στοίχιση στα αλφαριθμητικά, και στις δυο πλευρές.  Τα 5,6,7,8 εξαφανίζουν όποια λέξη δεν χωράει στην στήλη. Στην μη αναλογική γραφή έχουμε το 0 αντίστοιχο του 4, και τα 1,2,3 αντίστοιχα των 5,6,7.

Εισαγωγή αριθμού σε φόρμα
Το πιο προχωρημένο είναι η εισαγωγή αριθμού σε στοιχείο ελέγχου Εισαγωγή. Και αυτό γιατί εκεί υπάρχει τρόπος για έλεγχος τιμών εντός ορίων. Υπάρχει η διαμόρφωση Spinner η οποία δίνει στα άνω και κάτω βελάκια δυνατότητα να αλλάζουν τιμές, το ίδιο και το ροδελάκι του ποντικιού, με την μπάρα ολίσθησης που φαίνεται στο πλάι κίτρινο χρώμα, όπου παίζει το ρόλο ένδειξης) ενώ μπορούμε να γράψουμε τιμή. Το ενδιαφέρον εδώ είναι ότι ο έλεγχος εν μέρει γίνεται με κώδικα της Μ2000. Δηλαδή το στοιχείο όταν πάρει κάτι νέο, στέλνει μήνυμα το τι πήρε και που ήταν ο δρομέας, ενώ εκεί που λαμβάνουμε το μήνυμα μπορούμε να ξέρουμε την προηγούμενη κατάσταση σαν τιμή και σαν αλφαριθμητικό. Επειδή δουλεύει με ακέραιες τιμές μπορούμε να προσποιηθούμε ότι δεν είναι ακέραια με την κατάλληλη αλλαγή στο αλφαριθμητικό. Επειδή αυτός ο τρόπος χρησιμεύει και για αλλού, σε δεύτερο στοιχείο Εισαγωγή, το φτιάχνουμε σε ένα τμήμα. Οι συναρτήσεις που εξυπηρετούν μηνύματα καλούνται σαν να ήταν το τμήμα που έφτιαξε την φόρμα, οπότε σε κάθε περίπτωση βλέπουν ότι θα βλέπαμε σε αυτό το τμήμα, έτσι το τμήμα Αρ δεν χρειάζεται να είναι γενικό. Το Αρ το καλώ με την Κάλεσε αλλά γίνεται και χωρίς αυτήν! Δείτε επίσης ότι διαβάζουμε περισσότερα ορίσματα απ΄όσα βάζουμε στη Κάλεσε. Αυτό γίνεται γιατί στο σωρό τιμών ήδη υπάρχουν τα τελευταία δύο, και αντί να τα "σηκώσουμε" στην  Εισαγ1.ValidString   τα παίρνουμε μετά. Αυτό ξεχωρίζει την Μ2000 στο θέμα των παραμέτρων. Δεν χρειάζεται να δημιουργεί κανείς μεταβλητές και να επαναπροωθεί. Η κλήση τμημάτων γίνεται με παροχή του σωρού τιμών αυτού που καλεί (μπορούμε να κάνουμε και επιστροφή τιμών).
Το Αριθ=αλφα : Αλφα=Αριθ χρησιμεύει για να φέρει τον αριθμό στα μέτρα του Spinner. Δίνουμε τον αριθμό στο Spinner (έτσι λέμε αυτό που γυρίζει, όπως το σπιν στα ηλεκτρόνια), και αυτός αν είναι εκτός ορίων των πάει στο κοντινό άκρο. Οπότε τον διαβάζουμε μετά και έτσι έχουμε το τελικό!
Αν αποτύχει η μετατροπή της τιμής, τότε  η τοπική Άλφα δεν θα υπάρχει...δεν θα είναι Έγκυρο το Έγκυρο(αλφα) και απλά στέλνουμε το δρομέα στη θέση 100

Το σύμβολο & πριν το όνομα μεταβλητής σημαίνει "με αναφορά". Το βάζουμε όταν καλούμε κάτι και εκεί που καλούμε πρέπει η Διάβασε να έχει πάλι το & πριν την μεταβλητή, και έτσι ταυτίζεται η απαίτηση του καλούντος με την δυνατότητα του καλούμενου
Το παρακάτω το γράφουμε σε ένα τμήμα έστω Α (η Μ2000 τρέχει κώδικα σε πολλαπλές γραμμές μέσα σε τμήματα και συναρτήσεις). Θα μπορούσαμε στο τέλος να μην ορίσουμε τις μεταβλητές - αντικείμενα του γραφικού περιβάλλοντος- Εισαγ1, Εισαγ2 και Φόρμα1 όπως κάνουμε με το Τίποτα. Απλά το κάνουμε εδώ για να φαίνεται. Το τμήμα στην έξοδό του πάντα καθαρίζει τις δικές του μεταβλητές, άρα καθαρίζει και τις φόρμες (θα μπορούσε ένα προηγούμενο τμήμα στο δένδρο κλήσεων να είχε ανοίξει άλλη φόρμα)
Τα νούμερα στην μέθοδο "move" είναι σε twips. Στη Μ2000 χρησιμοποιούμε twips, που ισοδυναμούν με 15 στο Pixel (αλλά ενδέχεται να αλλάξει αυτό ανάλογα με το τι δίνει η οθόνη στον κάθε υπολογιστή ως dpi). Στον εκτυπωτή 1440 twips είναι πάντα μια ίντσα. Στην οθόνη λέγεται λογική ίντσα, όχι υπαρκτή, διότι πχ με προβολέα μπορούμε να αλλάζουμε το μέγεθος χωρίς να ενημερώνεται τίποτα στον υπολογιστή. Όταν λέμε κάτι "λογικό" σημαίνει ότι έχει μια έννοια, μια υπόσταση, αλλά περισσότερο μας ενδιαφέρει ο αριθμός αυτών, δηλαδή το μέγεθος, άρα η λογική ίντσα είναι απλά ένα μέτρο.



Τμήμα Αρ {
      Διάβασε &Αριθ, πως$, πολ, χωρις, &τροφ1$, &μιαθεση
      Τοπική προσ1
      αν όχι χωρίς τότε προσ1=αρισ$(τροφ1$,1)="-"
      Δες {
            Τοπική αλφα
            αλφα=Τιμη(τροφ1$,"")*πολ : Αριθ=αλφα : Αλφα=Αριθ
      }
      Αν Έγκυρο(άλφα) Τότε {
                 τροφ1$=γραφη$(απολ(αλφα)/πολ,πως$)
                Αν προσ1 Τότε τροφ1$="-"+τροφ1$
                Αν μιαθέση>μήκος(τροφ1$) τότε μιαθέση=1
      } Αλλιώς μιαθέση=100
}
Όρισε Φόρμα1 Φόρμα
Όρισε Εισαγ1 ΕΙΣΑΓΩΓΗ Φόρμα Φόρμα1
Όρισε Εισαγ2 ΕΙΣΑΓΩΓΗ Φόρμα Φόρμα1
Μέθοδος Εισαγ1 "Spinner", Αληθές, -1000, 2000, 50
Μέθοδος Εισαγ1,"move", 1000, 2000, 5000, 600
Με Εισαγ1, "Prompt", "Ύψος: ",  "Value" ως Αριθ, "VarText" ως Τροφ$, "ThisKind"," μέτρα"
Μέθοδος Εισαγ2 "Spinner", Αληθές, 0, 10000, 5
Μέθοδος Εισαγ2,"move", 1000, 2800, 5000, 600
Με Εισαγ2, "Prompt", "Απόσταση: ",  "Value" ως Αριθ2, "VarText" ως Τροφ2$, "ThisKind"," μέτρα"

Συνάρτηση Εισαγ1.ValidString {
      Κάλεσε Αρ, &Αριθ, ".00", 100, ψευδές
}


Συνάρτηση Εισαγ1.SpinnerValue {
            Διάβασε τιμ
            Τροφ$=γραφή$(τιμ/100,"0.00")
            }
Τροφ$="1,5"
Συνάρτηση Εισαγ2.ValidString {
      Κάλεσε Αρ, &Αριθ2, "", 1, αληθές
}
Συνάρτηση Εισαγ2.SpinnerValue {
            Διάβασε τιμ
            Τροφ2$=γραφή$(τιμ,"")
            }
Τροφ2$="200"
Μέθοδος Φόρμα1,"Show",1
Όρισε Εισαγ2 Τίποτα
Όρισε Εισαγ1 Τίποτα
Όρισε Φόρμα1 Τίποτα






Πέμπτη, 23 Μαρτίου 2017

Ενημέρωση του τεύχους 21 του εγχειριδίου

Καθώς συνεχίζω την ανανέωση του μικρού εγχειριδίου έκανα και μια αλλαγή στο απ' ευθείας εγχειρίδιο στο blog, στο παράδειγμα που στέλνoyme ένα πίνακα στο Ecxel (χωρίς να χειριστούμε το Excel ως αντικείμενο αλλά μέσω ενός csv αρχείου).
Η τροποποίηση δίνει την δυνατότητα να σώσουμε από το Excel το csv και να πάρουμε από την γραμμή με τους τύπους που είχαμε στο csv τα αποτελέσματα.
Το παράδειγμα φτιάχνει το csv με χώρισμα Tab ανά στοιχείο και με ότι είχουμε τοπικά σε χαρακτήρα δεκαδικού (στα ελληνικά έχουμε το κόμμα).
Όσο το αρχείο είναι ανοικτό στο Excel μπορούμε με να το διαβάσουμε αλλά δεν μπορούμε να το τροποποιήσουμε. Με αυτόν τον τρόπο, δοκιμάζοντας να το ανοίξει για συμπλήρωση (append), περιμένει να ελευθερωθεί, να κλείσει από το Excel. Υπάρχουν δυο περιπτώσεις. Να το έχουμε σώσει από το Excel, ή όχι. Αν όχι τότε θα είναι όπως το στείλαμε, αν ναι τότε δείτε τι κάνει το Excel. Δεν βάζει εισαγωγικά στα πεδία με αλφαριθμητικά. Οπότε πρέπει να βάλουμε εμείς. Επιπλέον αλλάζει τους τύπους (τα κελιά με = στην αρχή)  με το αποτέλεσμα. Για την τελευταία γραμμή κάνουμε το εξής: Παίρνουμε όλη τη γραμμή με Γραμμή Εισαγωγής (θα είναι τα αλφαριθμητικά με εισαγωγικά και οι αριθμοί με δεκαδικό τη τελεία, αφού κάναμε την μετατροπή πιο πριν). Όπως είναι η γραμμή εισαγωγής πηγαίνει στο σωρό με την εντολή Σωρός και οι τιμές μπαίνουν στη κορυφή του, οπότε δοκιμάζουμε να διαβάσουμε αλφαριθμητικά, αν δεν βγει η δοκιμή διαβάζουμε αριθμητικές τιμές!
άλλος τρόπος θα ήταν να κοιτάμε μια προς μια τις τιμές στο σωρό και ανάλογα να κάνουμε με την χρήση της Ειναρ (που γυρνάει -1 αν είναι αριθμός).

κ=1
\\ με χρήση BOM (ενδεικτικού χαρακτήρα)
\\ το 0xE δίνει το σύμβολο για τα δεκαδικά - μπορεί να είναι το κόμμα ή η τελεία.
Κάνε ΑλλαξεΤελεία$(α$)=αλλαγη$(".",τοπικο$(0xE),α$)
Δες οκ {
Άνοιξε "αλφα.csv" για ευρεία εξαγωγή ως κ
}
Αν όχι οκ Τότε Λάθος "Δεν μπορώ να ανοίξω το αρχείο αλφα.csv"
      Τύπωσε #κ, χαρκωδ$(0xFEFF);  \\ λέγεται BOM και μαρκάρει το κείμενο ως UTF-16LE
      \\ οι αριθμοί στο κώδικα γράφονται πάντα με τελεία για δεκαδικό
      \\ στην εμφάνιση στην Τύπωσε βγαίνουν βάσει του τοπικού
      Γράψε με χαρ$(9), τοπικο$(0xE)
      Γράψε #κ, "Τιμή Α", "Τιμή Β","Αποτέλεσμα Κ"
      Γράψε #κ, 12.24, 213.23, 213.23+12.24
      Γράψε #κ, 15.24, 215.23, 215.23+15.24
      Γράψε #κ, ΑλλαξεΤελεία$("=A2+A3*2.5"),ΑλλαξεΤελεία$("=B2+B3*2.5"),ΑλλαξεΤελεία$("=C2+C3*2.5")
Κλείσε #κ
Γράψε με "",""  \\ κάνουμε επιστροφή στις τιμές κόμμα και τελεία
Σύστημα "Excel.exe "+παράθεση$(κατ$+"αλφα.csv")
Έγγραφο Excel$
{
      Δες οκ {
            \\ αν είναι ανοιχτό με το Excel είναι για αποκλειστική χρήση
            \\ οπότε βγαίνει λάθος η συμπλήρωση (append)
            Άνοιξε "αλφα.csv" για συμπλήρωση ως κ
            Κλείσε #κ
            Φόρτωσε.Έγγραφο Excel$, "αλφα.csv"
      }
            αν λάθος ή οχι οκ τότε αναμονή 100 : κυκλικα
      }
Σώσε.Έγγραφο Excel$, "αλφα0.csv", 0
Σημ 1 : Σύστημα "Excel.exe "+παράθεση$(κατ$+"αλφα0.csv")


Αναφορά Excel$
\\ Μετατροπή από εξαγωγή του excel στο βασικό csv με κόμμα και τελεία.
Αν τοπικο$(0xE)<>"." Τότε {
      Για ι=1 έως Εγγράφου.Παρ(Excel$) {
            καθ$=παράγραφος$(Excel$,ι)+χαρ$(9)
            Έγγραφο τελικο$
            Ενώ καθ$<>"" {
                  καθ1$=αριστερομερος$(καθ$, χαρ$(9)) : καθ$=δεξιμερος$(καθ$, χαρ$(9))
                  καθ1$=αλλαγη$(τοπικο$(0xE),".",καθ1$)
                  Αν Εγγράφου.Μήκος(τελικο$)=0 τότε {
                        τελικο$=καθ1$
                  } Αλλιώς τελικο$=","+καθ1$
            }
            καθ$=τελικο$+"," : Καθαρό τελικο$
            Ενώ καθ$<>"" {
                  καθ1$=αριστερομερος$(καθ$, ",") : καθ$=δεξιμερος$(καθ$, ",")
                  \\ βάζουμε εισαγωγικά με την Παράθεση$() αν χρειάζεται
                  Αν όχι Δεξι$(καθ1$,1) ~ "[+-1234567890"+Χαρ$(34)+"]" τότε καθ1$=Παράθεση$(καθ1$)
                  Αν Εγγράφου.Μήκος(τελικο$)=0 τότε {
                        τελικο$=καθ1$
                  } Αλλιώς τελικο$=","+καθ1$
            }


            Καταχώρηση ι Excel$=τελικο$
            Καθαρό τελικο$ \\ καθαρίζουμε το έγγραφο
      }
}
Αναφορά Excel$
Σώσε.έγγραφο Excel$, "αλφα1.csv", 0


\\ Άνοιγμα του τροποποιημένου αρχείου, με κόμμα και τελείες.
Άνοιξε "αλφα1.csv" για ευρεία εισαγωγή ως κ
      Εισαγωγή #κ, τ1$, τ2$, τ3$
      Τύπωσε τ1$, τ2$, τ3$
      Για ι=1 έως 2 {
            Εισαγωγή #κ, τ1, τ2, τ3
            Τύπωσε τ1, τ2, τ3
      }
      Γραμμή Εισαγωγής #κ, ολα$
      Σωρός ολα$ \\ μεταφέρει στην κορυφή ότι έχει η γραμμή
      Δες Οκ {
            Διάβασε τ1$, τ2$, τ3$
            Τύπωσε τ1$, τ2$, τ3$
      }
      Αν όχι Οκ τότε {
            Διάβασε τ1, τ2, τ3
            Τύπωσε τ1, τ2, τ3
      }
Κλείσε #κ


Τρίτη, 21 Μαρτίου 2017

Αναθεώρηση 2 'Εκδοση 8.6


Σε αυτή την αναθεώρηση δεν υπήρξε διόρθωση λάθους. Απλά μπήκε κάτι που δεν είχε μπει στην 8.6 αναθ. 1, ο τρόπος να γνωρίζουμε τι έχει ο σωρός πριν κάνουμε κάποια ενέργεια. Αυτό γίνεται με την Ταύτιση() και στην 8.6 αναθ. 1 το σύστημα γύρναγε το U (undefined) και στην Ταύτιση() δεν υπήρχε γράμμα για αντικείμενο σωρού. Τώρα έχουμε το C και το Σ.


Η φάκελος τυπώνει πάντα το αγγλικό C. Η εντολή Σωρός χωρίς όρισμα δείχνει την λίστα περιεχομένων του σωρού, και εκεί εμφανίζει το *[mStiva].

Άδειασε \\ αδειάζει το σωρό
Σ1=Σωρός:=1,2,"Γεια",14
Βάλε Σ1
Τύπωσε Μέγεθος.Σωρού
Σωρός
Τύπωσε Φάκελος$() , Ταύτιση("C"), Ταύτιση("Σ"


 Η Μέγεθος.Σωρού δουλεύει για τον τρέχον σωρό, ενώ η Μήκος() για τους "Επώνυμους" σωρούς!

Ενημέρωσα τη βοήθεια για την Σωρός και την Κάθε(). Όταν είχε γραφτεί το πρώτο αρχείο βοήθειας, τα προγράμματα ήταν στα κεφαλαία...και εδώ το συνέχισα! Κάποια στιγμή θα τα ωραιοποιήσω! Το αντιγράφουμε σε ένα τμήμα έστω Α (με εντολή Σ Α και μετά ctrl+V, ή με drag n' drop, βγαίνουμε με Esc, και γράφουμε Α και τρέχει!).



      ΑΔΕΙΑΣΕ
      ΣΕΙΡΑ 1,2,3,4
      Α=ΣΩΡΟΣ:=20,10,1,2
      ΣΩΡΟΣ Α {
            ΣΩΡΟΣ
            ΠΕΤΑ 2
            ΣΩΡΟΣ
      }
      ΣΩΡΟΣ
      ΤΥΠΩΣΕ ΤΙΜΗΣΩΡΟΥ(Α), ΜΗΚΟΣ(Α) \\ 1   2
      ΣΩΡΟΣ Α {
            ΔΙΑΒΑΣΕ Χ, Υ
            ΓΙΑ ΑΥΤΟ { \\ ΠΡΟΣΩΡΙΝΟΙ ΟΡΙΣΜΟΙ
                  ΠΙΝΑΚΑΣ Μ(10)=5
                  ΒΑΛΕ Μ()
            }
      }
      Ν=ΣΩΡΟΣ(Α) \\ ΑΝΤΙΓΡΑΦΟ
      ΣΩΡΟΣ Ν {
            ΓΙΑ ΑΥΤΟ {
                  ΔΙΑΒΑΣΕ Κ \\ ΠΙΝΑΚΑΣ ΣΕ ΜΕΤΑΒΛΗΤΗ
                  Κ+=100
                  ΒΑΛΕ Κ
                  ΤΥΠΩΣΕ Κ \\ ΟΛΑ 105
                  ΣΩΡΟΣ Α {
                        ΔΙΑΒΑΣΕ Μ()
                        ΤΥΠΩΣΕ Μ() \\ ΟΛΑ 5
                  }
                  ΤΥΠΩΣΕ ΜΗΚΟΣ(Α) \\ 0
            }
      }
      Α=ΣΩΡΟΣ:="ΑΛΦΑ","ΒΗΤΑ", 100
      ΤΥΠΩΣΕ ΜΗΚΟΣ(Α), ΜΗΚΟΣ(Ν) \\ 3 & 1
      Ν=ΣΩΡΟΣ(Α,Ν) \\ ΝΕΟΣ ΣΩΡΟΣ ΩΣ Α+Β
      ΣΩΡΟΣ Ν {
            ΣΩΡΟΣ    \\ ΜΑΣ ΔΕΙΧΝΕΙ ΤΙ ΣΤΟΙΧΕΙΑ ΕΧΕΙ
      }
      ΣΩΡΟΣ Α {
            ΣΩΡΟΣ
      }
      Α=ΣΩΡΟΣ(Α,-3) \\ ΑΝΑΣΤΡΟΦΗ, ΤΟ ΤΕΛΕΥΤΑΙΟ ΓΙΝΕΤΑΙ ΠΡΩΤΟ
      ΣΩΡΟΣ Α {
            ΣΩΡΟΣ   \\ ΜΑΣ ΔΕΙΧΝΕΙ ΤΙ ΣΤΟΙΧΕΙΑ ΕΧΕΙ
      }
      ΣΩΡΟΣ ΣΩΡΟΣ(Α,-2) { \\ ΒΓΑΖΕΙ ΑΝΤΙΓΡΑΦΟ ΤΟΥ Α
      \\ ΤΑ ΔΥΟ ΤΕΛΕΥΤΑΙΑ ΣΤΟΙΧΕΙΑ ΕΙΝΑΙ ΣΕ ΑΝΑΣΤΡΟΦΗ
      \\ Ο Α ΠΑΡΑΜΕΝΕΙ ΩΣ ΕΧΕ
            ΣΩΡΟΣ
      }
      ΣΩΡΟΣ Α {ΠΕΤΑ} \\ ΠΕΤΑΕΙ ΤΗ ΚΟΡΥΦΗ
      Α=ΣΩΡΟΣ(Α,-ΜΗΚΟΣ(Α))
      ΝΝ=ΚΑΘΕ(Α)
      ΕΝΩ ΝΝ {
            ΤΥΠΩΣΕ ΤΙΜΗΣΩΡΟΥ$(ΝΝ)
      }




 

M2000 for Linux

Ο διερμηνευτής της Μ2000 μπορεί να τρέξει σε Linux. Υπάρχουν κάποια θέματα όπως με το κέρσορα (δεν αναβοσβήνει όπως θα έπρεπε όταν έχουμε σκοτεινά φόντα, ενώ δουλεύει με άσπρο φόντο καλά). Επίσης όταν ανοίγει ένα παράθυρο τύπου διαλόγου, πάνω από τη κονσόλα της Μ2000, τότε για ανεξήγητο λόγο νομίζει το Wine ότι θέλουμε κάτι από την γραμμή εκκίνησης και όχι μόνο την φέρνει στο προσκήνιο, παράλληλα παίρνει και το focus...οπότε η λύση είναι το Ctrl Tab, και κλικ στη φόρμα της Μ2000.

Η εγκατάσταση δεν είναι δύσκολη, όμως απαιτείται να οριστούν κάποιες βιβλιοθήκες με επιλογή native.
Στο στιγμιότυπο παρακάτω φαίνεται ο Task Manager του Wine, οι επιλογές στα dll, το πρόγραμμα σε Μ2000 Note1 (Notepad γραμμένο σε M2000), και ο διαχειριστής εργασιών του Linux (Ubuntu Studio 16.04 με Xfce)


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





Υπάρχει τρόπος να δούμε αν το πρόγραμμα τρέχει σε περιβάλλον Wine, σε Linux. Στην παρακάτω εικόνα βλέπουμε ότι εμφανίζει το λειτουργικό Windows 7, αλλά θα μπορούσε να ήταν και κάτι άλλο! Αυτό το αλλάζει το Wine. Υπάρχει όμως μια συνάρτηση στο ntdll που δεν την έχουν τα κανονικά ntdll, την wine_get_version. Η Μ2000 μπορεί να ενώσει μια δική της συνάρτηση με αυτήν και αν γίνει ...τότε ξέρουμε ότι τρέχει το πρόγραμμα σε Wine.  

Για να αντιγράψω τις παρακάτω δυο γραμμές, και να διατηρηθεί το χρώμα...πρέπει πρώτα να το φέρω στο Libreoffice, μετά να κάνω πάλι αντιγραφή και να το βάλω στο firefox, στο πλαίσιο του Blogger


declare Wine_Get_version lib "ntdll.wine_get_version" {}
report str$(uint(Wine_Get_version()) mod 0x80000)




Αρχεία κειμένου μπορούμε να ανοίγουμε χωρίς να τα φορτώσουμε στο περιβάλλον της Μ2000.

To note1.gsb  άνοιξε με την εντολή "note1.gsb". Αν κάναμε load note1.gsb θα έτρεχε άμεσα, γιατί τελευταίες εντολές έχει τις A : End  (καλεί το A και μόλις αυτό ολοκληρώσει κλείνει τον διερμηνευτή). Μάλιστα αν προσέξει κανείς τη πρώτη εικόνα...δεν βλέπει την κονσόλα γιατί την αφαιρούμε με την εντολή Title ή Τίτλος!

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

Μια άλλη ευκολία που "παίζει" και στο Linux είναι αλλαγή μεγέθους κονσόλας (αλλάζει και τα πλάτος/ύψος, αλλά εδώ θέλουμε να πιάνει όλη την οθόνη). Η κονσόλα έχει δυο εμφανή επίπεδα, το Περιθώριο και την Οθόνη. Στο περιθώριο γράφουμε με την εντολή Περιθώριο { } και μεσα στο μπλοκ όλες οι εντολές προς οθόνη πάνε στο Περιθώριο. Ομοίως και η Επίπεδο { } στέλνει στην οθόνη μέσα από την Περιθώριο { }. Η αλλαγή μεγέθους γραμμάτων γίνεται με τρεις τρόπους Mode ή Τύπος, Window ή Παράθυρο και Form ή Φόρμα. Ειδικά η τελευταία καθορίζει αυτόματα το linespace, ή διάστιχο δηλαδή το κενό μεταξύ των γραμμών.
Με form 40,20 δημιουργούμε ένα πλαίσιο οθόνης για 40 χαρακτήρες -  εσωτερικά η ρουτίνα υπολογίζει το πλάτος χαρακτήρα με βάσει το μέγεθος του W σε bold και Italic, και ψάχνει ανάστροφα, να δει σε ποιο μέγεθος χαρακτήρων έχει το βέλτιστο πλάτος. Αφού βρει το πλάτος και δει ότι οι γραμμές του φτάνουν, τότε υπολογίζει το διάστιχο.


Φαίνεται στη παραπάνω εικόνα το ευρύ διάστιχο! Δείτε ότι στη αριστερή πλευρά του τίτλου βλέπουμε το όνομα του αρχείου note1gsb (ενώ αν διορθώναμε το τμήμα Α θα έλεγε Τμήμα Α η Module A ανάλογα με τι γλώσσα έχουμε επιλέξει στις ρυθμίσεις (εντολή Ρυθμίσεις ή Ctrl+U στην γραμμή εντολών της κονσόλας της Μ2000)

Με form 30,20 μεγαλώνουν τα γράμματα και μειώνεται το διάστιχο, ενώ παραμένουν οι γραμμές κειμένου στις 20. Βλέπουμε το περιθώριο πιο μεγάλο. Τα νούμερα παίζουν από 10,2 και όσο θέλουμε ..(απλά δεν θα βλέπουμε αν το μέγεθος πέσει κάτω από το 6  - το τι είναι το έξι είναι μια άλλη συζήτηση)



Με πάτημα και ολίσθηση προς τα πάνω μετακινούμαστε στο κείμενο, με βελάκια, με σελίδα πάνω και κάτω, με την κρυφή μπάρα ολίσθησης (ανοίγει με το δείκτη του ποντικιού), και με το ροδελάκι στο ποντίκι.

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


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

Με Home /End πάμε αριστερά πρώτο ή δεξιά τελευταίο (για την ακρίβεια το Home μια φορά πάει στην θέση 1 και μια φορά στη θέση του πρώτου γράμματος μη διαστήματος (διάστημα είναι και ο χαρακτήρας 160, non-breaking space). Μπορούμε να δούμε τους κρυφούς χαρακτήρες με το F10, να δούμε τον αριθμό λέξεων με F9, να βγάλουμε/βάλουμε το χρωματισμό με το F11. Τα F6-F7-F8 είναι σελιδοδείκτες και δουλεύουν με ένα πάτημα ρύθμιση/επιλογή/απορύθμιση (αν έχουμε κάνει επιλογή η δεύτερη επιλογή κάνει απορύθμιση δηλαδή απελευθέρωση)
Τα F2 και F3 (δουλεύουν και με τα Shift) κάνουν αναζητήσεις πάνω και κάτω, Το F4 κάνει αλλαγή σε όλο το κείμενο σε λέξη που έχουμε αλλάξει γράμματα από πεζά σε κεφαλαίο ή και το ανάποδο, ώστε να κάνει όλες τις λέξεις το ίδιο. Το F5 κάνει αλλαγή σε όλο το κείμενο μιας λέξης με μια άλλη και μπορούμε να χρησιμοποιήσουμε το ctrl-z ως undo για να πάρουμε πίσω μερικές αλλαγές, και ctrl-y για redo.





Οι εντολές που γράφουμε στην κονσόλα φαίνονται με το edit (ή σ ή συγγραφή) χωρίς όρισμα. Εκεί μπορούμε να δούμε τις εντολές με χρώμα και να διορθώσουμε (παίζει και η βοήθεια, αλλά στο Linux το ctrl+F1 κάνει κάτι άλλο, οπότε υπάρχει στο μενού με δεξί κλικ ή με αριστερό στο τίτλο, κάτω - κάνει ολίσθηση το μενού- η επιλογή βοήθεια για εκείνη την λέξη που έχουμε επιλέξει)

Ο χρωματισμός του κειμένου από το αρχείο note1 γίνεται στον διορθωτή. Μάλιστα μόλις βγούμε από τον διορθωτή οι πληροφορίες του χρωματισμού χάνονται.

Στη παρακάτω εικόνα καλούμε με την εντολή Win το notepad (βγήκε αυτό του Wine, και ανοίγουμε το note1.gsb (αφού πάμε στο φάκελο UserName, Application Data, Μ2000 και επιλέξουμε όλα τα αρχεία, utf-8 κωδικοποίηση.


Παρατηρήστε τα αρχεία bck. Όταν σώνουμε ένα πρόγραμμα το παλιό δεν χάνεται, μέχρι την επόμενη φορά που θα ξανασώσουμε! Δείτε επίσης ότι το Wine δίνει δικό του διάλογο για άνοιγμα αρχείου που μοιάζει με τα windows, με ψειράκια γράμματα!




Ως προς το θέμα της ταχύτητας, στο WIne σαφώς ο διερμηνευτής είναι περίπου στο 70% από τον διερμηνευτή που τρέχει σε VirtualBox στο ίδιο μηχάνημα.

Καλές δοκιμές στο Linux!



Δευτέρα, 20 Μαρτίου 2017

Fibonacci Παράδειγμα.

Το πρόγραμμα δείχνει διάφορους τρόπους που βγαίνει η ακολουθία Fibonacci.
Παλαιότερα είχα δώσει ένα μικρό απλό πρόγραμμα, όπου το δείχνω μαζεμένο εδώ:

a=0 : b=1
fibonacci(20)
sub fibonacci(x)
if X>1 then fibonacci(X-1)
Print a, x : swap a, b :b+=a:x++
end sub


Υπάρχει τρόπος με απλή επανάληψη και χρήση δυο μεταβλητών, ο τρόπος να μας δίνει μια συνάρτηση λάμδα τις επόμενες τιμές σε κάθε εκτέλεση, και τρόποι με αναδρομή.
Στη λάμδα συνάρτηση δεν έχουμε όνομα να καλέσουμε, και καλούμε με το γενικό όνομα λάμδα() ή για επιστροφή αλφαριθμητικού την λάμδα$(). Μετά ακολουθεί η fib() όπου εκεί καλούμε με το όνομα fib() μέσα από την fib()
Τέλος έχουμε μια υπορουτίνα, όπου και αυτή έχει δυνατότητα αναδρομής αλλά εδώ κάνουμε το εξής αφήνουμε αποτελέσματα στο σωρό και παίρνουμε από εκεί. Δηλαδή χρησιμοποιούμε μια τοπική  μεταβλητή τη χ και το σωρό τιμών (με Push βάζουμε στη κορυφή, με Διάβασε τη σηκώνουμε, αλλά εδώ χρησιμοποιώ την Αριθμός/Number και με μια Push Number+Number, τραβάμε τα δυο πρώτα τα προσθέτουμε και βάζουμε το αποτέλεσμα στη κορυφή του σωρού)

Recursion.limit  \\ just infrorm about the limits
\\ limit for function can't be change from program
\\ we can change limit for subs


\\ A loop in a function
Fibonacci=lambda (x)-> {
      Let A=0, B=1
      If x<=1 then =0 : exit
      For i=1 to x-1 {
            Push B : B=A+B: Read A
      }
      =A
}
\\ Same as before but without loop
\\ Also lambda capture A and B
FibonacciNext=lambda A=0, B=1-> {
      =A
      Push B : B=A+B: Read A
}
Print Fibonacci(5)
\\ A is a copy lambda with A and B zero
A=FibonacciNext
For I=1 to 10 { Print A(), } \\ print using columns
Print   \\ new line


\\ Recursion  (max 3375 level of recursion)
FibonacciRecursion=lambda (x) ->{
            if x<=1 then =0 : exit
            if x=2 then =1 : exit
            =lambda(x-1)+lambda(x-2)
}
Print FibonacciRecursion(5), Fibonacci(5)
Print FibonacciRecursion(10), Fibonacci(10)
Function Fib (x) {
      if x<=1 then =0 : exit
      if x=2 then =1 : exit
      =Fib(x-1)+Fib(x-2)
}
Print Fib(15),FibonacciRecursion(15), Fibonacci(15)
Print "Press a key"
A$=Key$
S=stack.size
FibonacciSub(15)
Print Number \\ pop value from stack


\\ sub with recursion, using M2000 stack for values/Parameters
\\ If we don't call subs between blocks of code in brackets { } then
\\ we get high recursion depth level
Rem : Recursion.Limit 500000
Sub FibonacciSub(x)
      if x<=1 then Push 0: Exit Sub
      if x=2 then Push 1: Exit Sub
      FibonacciSub(x-1)
      FibonacciSub(x-2)
      Push Number+Number \\ Number is pop
      \\ Unhide Stack to see stack values
      \\ Stack size as a bar graph
      Print String$("*",stack.size-S)
End Sub