Γενικός Απαριθμητής Συνδυασμών II (με κλάση -Νέο)

Σε αυτό το παράδειγμα έχουμε μια κλάση και φτιάχνουμε ξεχωριστές οντότητεςόπου η καθεμία είναι ένας μετρητής. Ο πρώτος που φτιάχνουμε σε αυτό το παράδειγμα θα μετράει από το 1 και για 3 βήματα. Ο δεύτερος το ίδιο αλλά όταν περνάει στο τέταρτο βήμα τότε δίνει εντολή στον προηγούμενο να μετρήσει! Αυτό γίνεται με την ισχνή αναφορά. Λέγεται ισχνή διότι δίνεται μόνο το όνομα αλλά δεν γίνεται η αναφορά. Και εδώ στην ουσία τη χρησιμοποιούμε με την εντολή Ένθεση (Inline) για να παρεμβάλουμε κώδικα! Στην μεταβλητή της κλάσης (του κάθε αντικειμένου) .ισχνή$ θα είναι το πραγματικό όνομα του μετρητή που θέλουμε να εκτελείται η "μέτρησε".

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

Το ενδιαφέρον εδώ είναι ότι μπορούμε να δώσουμε σε κάθε μετρητή άλλο αριθμό βημάτων. Θα μπορούσε να φανταστεί κανείς τον κάθε μετρητή ως γρανάζι με δόντια! Θα βάζαμε δηλαδή μια σειρά γρανάζια και θα τα γυρίζαμε ανάλογα με την ένδειξη του κάθε μετρητή!

Διόρθωση  - Βελτιστοποιήθηκε

Κλάση μετρ {
      αρ,μηδ=0,μεγ=1,μεγ1=0,ισχνή$
      συνολο
      Τμήμα μετρησε { κ=0
            Αν Ταύτιση("Α") Τότε διαβασε κ
            \\ ένα μπλοκ με την κυκλικά κάνει επανάληψη
            \\ η εντολή κυκλικά αλλάζει μια σημαία εσωτερικά
            \\ ο έλεγχος της σημαίας γίνεται στο τέλος του μπλοκ
            {
                  κ--
                  .αρ++
                  .συνολο++
                  Αν .αρ>.μεγ1 Τότε {
                        .αρ<=.μηδ
                        Αν .ισχνη$<>"" Τότε ενθεση .ισχνη$+".μέτρησε"
                  }
                  Αν κ>0 Τότε κυκλικά
                  }
      }
      Τμήμα μετρ {
            Αν Ταύτιση("ΑΑ") Τότε {
                  διάβασε .μηδ, .μεγ : .μεγ1<=.μεγ-1+.μηδ
                  .αρ<=.μηδ
            } Αλλιώς.Αν Ταύτιση("Α") Τότε {
                  διάβασε .μεγ : .μεγ1<=.μεγ-1
                  .αρ=.μηδ
            }
            Αν Ταύτιση("Γ") Τότε {
                  Διάβασε .ισχνη$
            }
      }
      Συνάρτηση ολαμαζί$ {
            α$=""
            Αν .ισχνη$<>"" Τότε ενθεση "α$= "+.ισχνη$+".ολαμαζι$()"
            Αν α$="" Τότε {
                  =α$+Μορφή$("{0}",.αρ)
            } Αλλιώς {
                  =α$+Μορφή$(", {0}",.αρ)
            }
      }
}

Α1=μετρ(1,3)
Α2=μετρ(1,3,&Α1)
Α3=μετρ(1,3,&Α2)
Α4=μετρ(1,3,&Α3)
Α5=μετρ(1,3,&Α4)
α5.μετρησε 100
Για α5 {
      Για ι=1 Έως 100 {
      Τύπωσε .ολαμαζί$(), .συνολο
      .μετρησε
      }
}



\\ Μετρητής δυαδικός 8bit

Α1=μετρ(0,2)
Α2=μετρ(0,2,&Α1)
Α3=μετρ(0,2,&Α2)
Α4=μετρ(0,2,&Α3)
Α5=μετρ(0,2,&Α4)
Α6=μετρ(0,2,&Α5)
Α7=μετρ(0,2,&Α6)
Α8=μετρ(0,2,&Α7)
Α8.μετρησε 128

Για Α8 {
      Για ι=1 Έως 10 {
      Τύπωσε .ολαμαζί$(), .συνολο
      .μετρησε
      }
}

Επίδειξη της Ομάδας (αντικείμενο στην Μ2000)

Παραθέτω το κώδικα έχει επεξηγήσεις (θέλει την αναθεώρηση 101)

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

\ Δυο είναι τα χαρακτηριστικά των ομάδων:
\ Οι συναρτήσεις και τα τμήματα βλέπουν τα αναγνωριστικά στο ίδιο επίπεδο.
\ Αν έχουμε μια ομάδα σε μια ομάδα τότε οι συναρτήσεις μέσα στη φωλιασμένη ομάδα δεν βλέπουν τα αναγνωριστικά της εξωτερικής. Το ανάποδο όμως γίνεται, μόνο για τα αναγνωριστικά της ομάδας όχι των τμημάτων/συναρτήσεων εσωτερικά.
\ Τα τμήματα και οι συναρτήσεις δημιουργούν μεταβλητές όταν τρέχουν μόνο, έτσι από μια εξωτερική ομάδα δεν έχουμε πρόσβαση σε μεταβλητές εντός τμήματος, παρά μόνο να το τρέξουμε. Παραστατικά οι ομάδες βλέπουν στο βάθος, στη λίστα των περιεχομένων τους,  ενώ τα τμήματα στην επιφάνεια, στη λίστα που περιέχονται!
\ Οι ορισμοί των τμημάτων είναι φυσικά όρια ενώ των ομάδων δεν είναι. Δηλαδή το τμήμα μπορούμε να το αλλάξουμε αλλά όλο μαζί δίνοντας με το ίδιο όνομα νέο ορισμό. Στην ομάδα ότι υπάρχει ως όνομα μένει! Μπορούμε να προσθέσουμε ότι θέλουμε, να αλλάξουμε τις διαστάσεις πινάκων αλλά δεν μπορούμε μια ομάδα στην ομάδα να την σβήσουμε αφού έχει όνομα, άρα δεν σβήνει.
\ Πότε σβήνουν οι ομάδες;
\ Οι ομάδες σβήνουν, διαγράφονται, όταν διαγράφονται αυτοί που τις κρατούν.
\ Μπορεί μια ομάδα να την κρατάνε δυο ή περισσότερα αναγνωριστικά;
\ Γίνεται με την έννοια της αναφοράς, αλλά μια αναφορά δεν μπορεί να πάρει νέα αναφορά!
\ Υπάρχουν δείκτες όμως;
\ Όχι δεν υπάρχουν δείκτες που θα "κρατούσαν" σε ζωή μια ομάδα εκτός τμήματος
\ Και πώς γίνεται να μείνει μια ομάδα εκτός τμήματος και πώς γίνεται να επιστραφεί από συνάρτηση;
\ Μια ομάδα γίνεται να αντιγραφεί, σε ένα νέο όνομα, στον επεξεργαστή εκφράσεων ως ομάδα χωρίς όνομα!
\ Επίσης μπορούμε ομάδες χωρίς όνομα να έχουμε σε στοιχεία πινάκων
\ Αντί να έχουμε δείκτες να δείχνουν αντικείμενα και να πρέπει να τους διαχειριστούμε γιατί
\ αλλιώς δεν θα διαγραφούν, έχουμε υποστηρικτές (holders) που κρατούν το αντικείμενο και
\ δεν μοιράζονται τον ιδιωτικό τους δείκτη!
\ Στη Μ2000 δεν μπορούμε να φτιάξουμε αναφορά σε στοιχείο πίνακα. Όμως μπορούμε να φτιάξουμε
\ αναφορά στον πίνακα!

' Στο παράδειγμα δημιουργούμε την ομάδα άλφα άμεσα.
' Αν βάλει κανείς την εντολή Λίστα θα δει ότι υπάρχει η άλφα.γ για παράδειγμα.
' Και αυτό γιατί "δεν υπάρχουν σύνορα" στις ομάδες.
' Στην ομάδα αυτή δημιουργούμε την ομάδα βητα από την κλάση βητα1
' Μπορούσαμε να γράψουμε απ΄ευθείας Ομάδα βήτα  { } και να καταργήσουμε τη κλάση
' Θέλουμε όμως να κάνουμε και άλλα βήτα μέσα σε έναν πίνακα.
' Στον ορισμό δεν μπορούμε να εκτελέσουμε κώδικα (απλές τιμές περνάμε)
' Οπότε έχουμε ένα τμήμα που αλλάζει την διάσταση του πίνακα Α()
' Συνάμα του δίνει τη κλάση βήτα1 για να γεμίσει τον πίνακα (σε αυτή τη περίπτωση οι συναρτήσεις και τα τμήματα ως ορισμοί γράφονται σε μια λίστα στο πίνακα, αλλά μπορούμε να έχουμε πίνακες με ανακατεμένες κλάσεις, όπως θέλουμε εμείς)
' Δείτε όμως ότι η βήτα1 έχει μια συνάρτηση παραγοντικό. Μπορούμε να το καλέσουμε και αυτό να καλέσει τον εαυτό του. Και αυτό θα γίνει με διάφορους τρόπους:
' Θα γίνει από την άλφα με κλήση της βγάλε_παραγοντικό() που έμμεσα καλεί το βήτα.βγάλε_παραγοντικό()
' Θα γίνει από το ανώνυμο στοιχείο 3 του πίνακα αλφα.α(3) με χρήση της  άλφα.α(3).παραγοντικό()
' (το ανώνυμο στοιχείο έχει όμως θέση στο πίνακα, για όσο είναι σε αυτή τη θέση, διότι οι πίνακες είναι δυναμικοί)
' Θα γίνει από έναν άλλο πίνακα Α() στο τμήμα στο οποίο βγάλαμε ένα αντίγραφο του Αλφα
' Άρα στο Α(3) του πίνακα θα είναι και το Α(3).α(3).παραγοντικό() αλλά ως αντίγραφο, όχι το ίδιο το ίδιο το άλφα!
' Τέλος δοκιμάζουμε τις αναφορές με κλήση σε τμήμα Δείξεμου1 και Δείξεμου2
' Για να περάσω στοιχείο πίνακα πρέπει να δώσω τον πίνακα χωριστά με το δείκτη στο πίνακα
' Όμως δείτε τώρα: Η Παραγοντικό τρέχει με αναδρομή μέσα σε ένα τμήμα ενώ βρίσκεται σε πίνακα που βρίσκεται ή σε μια ομάδα ή σε ένα άλλο πίνακα σε μια ομάδα!
' Δείτε και τον υπολογισμό με το γ

Ομάδα αλφα {
      κλάση βητα1 {
            γ=2
            δ=3
            Συνάρτηση Παραγοντικό {
            Διάβασε π
            .γ<=.δ+2*.γ
            Αν π<2 Τότε { =1 } Αλλιώς  =.Παραγοντικό(π-1)*π
            }
       }
      βητα1 βητα
      γ=100
      Πίνακας α()
      Τμήμα ΦτιάξεΠίνακα {
            Πίνακας .α(20)=.βητα1()
      }
      Πίνακας κ(5)=100
      Συνάρτηση κάποια {
            =.γ*100
      }
      Συνάρτηση βγάλε_παραγοντικό {
             Διάβασε α
            =.βήτα.παραγοντικό(α)
      }
}
Τύπωσε αλφα.βγάλε_παραγοντικό(10)
αλφα.ΦτιάξεΠίνακα
' κάθε στοιχείο στο άλφα.α() έχει την παραγοντικό()
Τύπωσε άλφα.α(3).παραγοντικό(10) ' 3628800

Πίνακας Α(100)
Α(3)=άλφα
Τύπωσε Α(3).βγάλε_παραγοντικό(10) ' 3628800
Τύπωσε Α(3).α(3).παραγοντικό(10), Α(3).α(3).γ '3628800, 5242877

Τμήμα Δείξειμου1 {
      Διάβασε &άλλο_άλφα
      Τύπωσε άλλο_άλφα.α(3).παραγοντικό(10), άλλο_άλφα.α(3).γ ' 3628800, 5242877
}

Δείξειμου1 &άλφα
\\ προσέξτε εδώ το γ έχει άλλη τιμή γιατί την έχουμε αλλάξει με αυτό Α(3).α(3).παραγοντικό(10)
Τμήμα Δείξεμου2 {
      Διάβασε &άλλο_άλφα(), ι
      Τύπωσε άλλο_άλφα(ι).α(3).παραγοντικό(10), άλλο_άλφα(ι).α(3).γ ' 3628800, 5368709117
}

Δείξεμου2 &Α(), 3
Τύπωσε Α(3).α(3).γ ' 5368709117

Γενικός Απαριθμητής Συνδυασμών

βρήκα ένα bug όταν δίναμε μηδενική τιμή στον ορισμό πίνακα: Πίνακας Α(10)=0
(κανονικά με Πίνακας Α(10) έχουμε μηδενική τιμή)
Διορθώθηκε στην 101 αναθεώρηση.

Θέλουμε να μετρήσουμε και να δείξουμε όλους τους συνδυασμούς  ενός απαριθμητή. Ο απαριθμητής μας έχει μετρητές σε σειρά, ώστε ο πρώτος μετρητής να γυρίζει τον δεύτερο όταν κάνει ν βήματα.
Ας πούμε ότι έχουμε δυο ζάρια, άρα ο απαριθμητής μας θα είναι δυο μετρητών με έξι βήματα ο καθένας. Έχουμε τον δείκτη νιοστό που αν είναι αληθές τότε μετράει από το 1 αλλιώς μετράει από το 0. Εδώ θέλουμε από το 1 για να πάρουμε όλους τους συνδυασμούς από 1,1 έως 6,6

Αν θέλουμε να βγάλουμε τους δυαδικούς αριθμούς 4 ψηφίων τότε θέλουμε:
νιοστό=ψευδές :ν=2: μετρητές=4 

Αν θέλουμε τους οκταδικούς από το 000 έως το 777 τότε θέλουμς
νιοστό=ψευδές :ν=8: μετρητές=3

Για τα πρώτα 256 δυαδικά των 8bit:
νιοστό=ψευδές :ν=2: μετρητές=8


φορμα 80,40
νιοστό=ψευδές \\ αληθές μετράει την εμφάνιση σειράς από 1, ψευδές από 0
ν=8 \ ο κάθε μετρητής από 0 έως ν-1
μετρητές=2
\\ βοηθητικές ν1 και μετ1
αν νιοστό τότε {
      ν0=1
      ν1=ν
} αλλιώς {
      ν0=0
      ν1=ν-1
}
πινακας μετρ(μετρητές)=ν0
μετ1=μετρητές-1
τόσο=ν**μετρητές
πόσο=τόσο
αν νιοστό τότε πόσο++
Επανέλαβε {
      Για ι=μετ1 έως 0: Τύπωσε μετρ(ι), : Επόμενο ι : Τύπωσε πόσο-τόσο
      ι=0
      μετρ(ι)++
      ενώ μετρ(ι)>ν1 {
            μετρ(ι)=ν0
            ι++
            αν ι>μετ1 τότε έξοδος
            μετρ(ι)++
      }
      τόσο--
} μέχρι τόσο=0

Αναθεώρηση 100 - διόρθωση σφάλματος!

Στο παρακάτω παράδειγμα χρησιμοποιώ μια εντολή  Παιδί α μέσα στον ορισμό της κλάσης Πατέρας. Στις τελευταίες αναθεωρήσεις (μετά την 93) είχε χαλάσει αυτή η λειτουργία, και τώρα στην αναθεώρηση 100 διορθώθηκε. Η δουλεία της είναι να φτιάξει μια κλάση από μια υπάρχουσα κλάση κατά τον ορισμό της. Δεν μπορούμε όμως να περάσουμε στοιχεία στον κατασκευαστή της. Αν θέλουμε να περάσουμε στοιχεία πέρα από τα αρχικά, τότε πρέπει να βάλουμε εδώ έναν κατασκευαστή για την Πατέρας με ένα τμήμα με το όνομα Πατέρας και να βάλουμε
      Ομάδα α
      Τμήμα Πατέρας {
      .α<=.Παιδί(10,20,30)
      }
Οπότε φτιάχνεται αρχικά μια άδεια ομάδα και μετά βάζουμε την ομάδα που θέλουμε!
Δείτε ότι στον κατασκευαστή βάζουμε τελείες για να αναφερθούμε στο ΑΥΤΟ (που φτιάχνει η κλάση, και είναι κάτι που θα έχει παρουσία). Δείτε επίσης ότι έχει χρησιμοποιηθεί "<=" που χρειάζονται οι μεταβλητές της κλάσης για να δώσουμε μια τιμή (ή μια ομάδα), και είναι το ίδιο με αυτό που χρησιμοποιούμε για να δώσουμε τιμή σε γενική μεταβλητή.

Κλάση Πατέρας {
      Συνάρτηση Καλή {
            =1000
      }
      Κλάση Παιδί {
             χ, ψ=10, ζ
             Συνάρτηση Καλή {
             =10000
             }
             Τμήμα Παιδί {
             Αν Ταύτιση("ΑΑΑ") τότε {
                   Διάβασε .χ, .ψ, .ζ
                   }
             }
      }
      Παιδί α
      Τμήμα Παιδί {
      β=.Παιδί()
      ? β.ψ
      }
}
' Τώρα θα φτιάξουμε ένα αντικείμενο (ομάδα) από την κλάση Πατέρας
αλφα=Πατέρας()
' το άλφα έχει μια ομάδα Α που έχει ένα αντίγραφο της κλάσης Παιδί.
' Έχει ένα τμήμα Παιδί και μια συνάρτηση Παιδί() που παράγει αντίγραφα της κλάσης Παιδί
' Έχει επίσης και μια Καλή() συνάρτηση!
' Στο τμήμα Παιδί φτιάχνουμε πρόσκαιρα μια ομάδα από την κλάση Παιδί
' Καλούμε το τμήμα (μπορούμε να το καλέσουμε και με την Κάλεσε
αλφα.Παιδί  ' τυπώνει 10
Κάλεσε αλφα.Παιδί ' ξαναφτιάχνει τη τοπική ομάδα β
' Τώρα μπορούμε να καλέσουμε την συνάρτηση Καλή()
' Σε μια τύπωσε
Τύπωσε αλφα.Καλή() ' 100
' Το α που βρίσκεται στο άλφα έχει και αυτό μια συνάρτηση Καλή() διαφορετική.
? αλφα.α.καλή() ' 10000
' Τώρα θα φτιάξω ένα παιδί..δίχως πατέρα!
' Μάλιστα δίνω και νέες τιμές που θα τις πάρει ο κατασκευαστής (τμήμα Παιδί)
βήτα=άλφα.Παιδί(100,200,300)
' Πράγματι το βήτα.χ είναι 100
? βήτα.χ ' 100
' Θα το αυξήσω τώρα - θα γίνει 101
βήτα.χ++
' Τώρα θα αντιγράψω ότι έχει στο α που είναι στο άλφα!
αλφα.α=βήτα '' αντιγράφουμε το βήτα στο αλφα.α
' Πράγματι το άλφα.α.χ είναι 101
? αλφα.α.χ

Πίνακας Αληθείας (μικρό πρόγραμμα- διορθώθηκε)

Ένα πρόγραμμα που κάνει την εξαγωγή αριθμών (το αληθές είναι το -1 και ψευδές το 0) να βγαίνουν με ονόματα! Αυτό μπορεί να γίνει γενικά (δεν φαίνεται εδώ πώς)...αλλά και ειδικά με την Γραφή$().
Επιπλέον βλέπουμε και την χρήση γενικής μεταβλητής.

Ο τύπος της Xnor είναι έτσι: 
Επεξήγηση: το επί είναι ο λογικός πολλαπλασιασμός (Και) το συν είναι η λογική πρόσθεση (Ή) και οι παύλες υποδηλώνουν την αναστροφή, το Not ή Όχι εδώ.
Η Κάνε φτιάχνει μια Συνάρτηση {}...η ΌχιΑπό$() θα μπορούσε να γραφτεί έτσι:
Συνάρτηση ΌχιΑπό$ {
      Διάβασε α, β
      =Γραφή$((α Και β) ή ( Όχι α Και Όχι β), τρόπος_εμφάνισης$) 
}

Οι δυο τρόποι είναι ισοδύναμοι εδώ. Απλά η Συνάρτηση έχει μπλοκ εντολών, άρα μπορούμε να την επεκτείνουμε με πολλές εντολές κώδικα αν χρειάζεται.
Επιπλέον η Συνάρτηση έχει και αυτή τη μορφή Συνάρτηση Γενική ΌχιΑπό$ { }, δηλαδή παίρνει το αναγνωριστικό Γενική και μέχρι να διαγραφεί θα φαίνεται και σε άλλες συναρτήσεις, αν θέλουμε να την καλέσουμε, όπως φαίνεται η γενική μεταβλητή τρόπος_εμφάνισης$


\\ Πίνακας αληθείας για την XNOR (not XOR, eXclusive Not OR)
Γενική τρόπος_εμφάνισης$=";Αληθές;Ψευδές;"
Κάνε ΌχιΑπό$(α, β)=Γραφή$((α Και β) ή (Όχι  α Και Όχι β), τρόπος_εμφάνισης$)  
Κάνε ΑπλήΌχιΑπό$(α,β)=Γραφή$(Όχι (α Από β), τρόπος_εμφάνισης$)
Κάνε Λογική$(α)=Γραφή$(α, τρόπος_εμφάνισης$)
Τύπωσε $(4),    '' γυρνάμε σε αναλογική γραφή στη κονσόλα
Για ι=Αληθές Έως Ψευδές {
      Για κ=Αληθές Έως Ψευδές {
            Τύπωσε μορφή$("Xnor({0},{1})={2}   [{3}]", Λογική$(ι), Λογική$(κ), ΌχιΑπό$(ι, κ), ΑπλήΌχιΑπό$(ι,κ))
      }
}

Έλεγχος Μαγικού Πίνακα ν διαστάσεων (Νέο και με Κλάση)

Διόρθωση:
Γενικά οι παλαιές αναθεωρήσεις με τις νέες έχουν ~99.9% συμβατότητα Εδώ το πρόγραμμα με τη κλάση χρησιμοποιεί την "κάλεσε" για να καλέσει μια συνάρτηση. Αυτό γίνεται μεν αλλά έχει μια αλλαγή. Αν επιστρέψουμε αριθμό άλλο από 0 τότε αυτός ειναι αριθμός λάθους! Για να αποφύγουμε τον έλεγχο, καλούμε την συνάρτηση σαν κενή, χωρίς δηλαδή επιστροφή τιμής.

Η συνάρτηση ΈλεγχοςΜαγικού() δουλεύει για κάθε πίνακα ν*ν. Υπολογίζει αθροίσματα στηλών, γραμμών και διαγωνίων
Εδώ δίνουμε έναν πίνακα 3Χ3.
Στο παράδειγμα τυπώνει -1 μετά 0 και μετά -1 (τον ξαναφτιάχνει σωστό).
Έχουμε εδώ μια συνάρτηση σε συνάρτηση. Η Άθροισμα() είναι βοηθητική συνάρτηση.
Θα έπρεπε να την ορίσουμε γενική για να την είχαμε απ΄έξω από την ΈλεγχοςΜαγικού() ή να την δύναμε με αναφορά (Η Μ2000 περνάει με αναφορά και συναρτήσεις)

Συνάρτηση ΈλεγχοςΜαγικού {
      Διαβασε &Α()
      ν=Διάσταση(Α(),1)
      Αν Διάσταση(Α(),2)<>ν τότε έξοδος
      Συνάρτηση Άθροισμα {
            καθαρο Σούμα
            Διάβασε &π(), Θχ,Θυ, Πχ, Πυ, Επ
            Για Επ=Επ-1 εως 0
                  Σούμα+=π(Θχ,Θυ)
                  Θχ+=Πχ
                  Θυ+=Πυ
            Επόμενο Επ
            =Σούμα
      }
      Μαγικός=Άθροισμα(&Α(),ν-1,0,-1,1,ν)
      οκ=αληθές
      για ι=0 εως ν-1
            οκ=Άθροισμα(&Α(),0,ι,1,0,ν)=Μαγικός και οκ
            οκ=Άθροισμα(&Α(),ι,0,0,1,ν)=Μαγικός και οκ
      επόμενο ι
      =Άθροισμα(&Α(),0,0,1,1,ν)=Μαγικός και οκ
}
Αναφορά {Ένα τετράγωνο θεωρείται μαγικό αν το άθροισμα των αριθμών των γραμμών, των στηλών και των διαγωνίων του είναι σταθερός αριθμός.}
Πίνακας β(3,3)
      β(0,0)=4,9,2
      β(1,0)=3,5,7
      β(2,0)=8,1,6
Τύπωσε ΈλεγχοςΜαγικού(&β())
β(2,1)++
Τύπωσε ΈλεγχοςΜαγικού(&β())
β(2,1)--
Τύπωσε ΈλεγχοςΜαγικού(&β())



Παρακάτω η συνάρτηση Άθροισμα() δίνεται με αναφορά στην ΈλεγχοςΜαγικού()

Συνάρτηση Άθροισμα {
      καθαρο Σούμα
      Διάβασε &π(), Θχ,Θυ, Πχ, Πυ, Επ
      Για Επ=Επ-1 εως 0
            Σούμα+=π(Θχ,Θυ)
            Θχ+=Πχ
            Θυ+=Πυ
      Επόμενο Επ
      =Σούμα
}
Συνάρτηση ΈλεγχοςΜαγικού {
      Διαβασε &Α(), &Όλο()
      ν=Διάσταση(Α(),1)
      Αν Διάσταση(Α(),2)<>ν τότε έξοδος
      Μαγικός=Όλο(&Α(),ν-1,0,-1,1,ν)
      οκ=αληθές
      για ι=0 εως ν-1
            οκ=Όλο(&Α(),0,ι,1,0,ν)=Μαγικός και οκ
            οκ=Όλο(&Α(),ι,0,0,1,ν)=Μαγικός και οκ
      επόμενο ι
      =Όλο(&Α(),0,0,1,1,ν)=Μαγικός και οκ
}
Αναφορά {Ένα τετράγωνο θεωρείται μαγικό αν το άθροισμα των αριθμών των γραμμών, των στηλών και των διαγωνίων του είναι σταθερός αριθμός.}
Πίνακας β(3,3)
      β(0,0)=4,9,2
      β(1,0)=3,5,7
      β(2,0)=8,1,6
Τύπωσε ΈλεγχοςΜαγικού(&β(),&Άθροισμα())
β(2,1)++
Τύπωσε ΈλεγχοςΜαγικού(&β(),&Άθροισμα())
β(2,1)--
Τύπωσε ΈλεγχοςΜαγικού(&β(),&Άθροισμα())

Με κλάση
Το ίδιο πρόγραμμα με κλάση, όπου εκεί κρατάμε τα στοιχεία σε εσωτερικό πίνακα. Έχω χρησιμοποιήσει αναφορά σε συνάρτηση μέσα στη κλάση!
Επιπλέον έχω βάλει μια συνάρτηση για να μας δώσει την τάξη του πίνακα (3 για 3Χ3)
Και έχω βάλει και την ιδιότητα ΜαγικόςΑριθμός

Κλάση ΜαγικόςΠίνακας {
      Πίνακας Α()
      ΜαγικόςΑριθμός
      Τμήμα ΜαγικόςΠίνακας {
      ν=μέγεθος.σωρού
      ν1=ακ(ρίζα(ν))
      αν ν1>=1 τότε {
            Πίνακας .Α(ν1*ν1) ' τον κάνω μονοδιάστατο
            Για ι=0 έως ν1*ν1-1 : Διάβασε .Α(ι) : Επόμενο ι
            Πίνακας .Α(ν1,ν1) ' τον κάνω ν1Χν1
            Κάλεσε κενή .Έλεγχος()
      }
      }
      Συνάρτηση Άθροισμα {
            καθαρο Σούμα
            Διάβασε Θχ,Θυ, Πχ, Πυ, Επ
            Για Επ=Επ-1 εως 0
                  Σούμα+=.Α(Θχ,Θυ)
                  Θχ+=Πχ
                  Θυ+=Πυ
            Επόμενο Επ
            =Σούμα
      }
      Συνάρτηση Ν {=Διάσταση(.Α(),1)}
      Συνάρτηση ΈλεγχοςΜαγικού {
            Διάβασε &σειρά()
            αν Διάσταση(.Α())=0 τότε έξοδος
            ν=.Ν()
            .ΜαγικόςΑριθμός<=σειρά(ν-1,0,-1,1,ν)
            οκ=αληθές
            για ι=0 εως ν-1
                  οκ=σειρά(0,ι,1,0,ν)=.ΜαγικόςΑριθμός και οκ
                  οκ=σειρά(ι,0,0,1,ν)=.ΜαγικόςΑριθμός και οκ
            επόμενο ι
            =σειρά(0,0,1,1,ν)=.ΜαγικόςΑριθμός και οκ
      }
      Συνάρτηση Έλεγχος {
            =.ΈλεγχοςΜαγικού(&.Άθροισμα())
      }
}
Αναφορά {Ένα τετράγωνο θεωρείται μαγικό αν το άθροισμα των αριθμών των γραμμών, των στηλών και των διαγωνίων του είναι σταθερός αριθμός.}
β=ΜαγικόςΠίνακας(4,9,2,3,5,7,8,1,6)
Τύπωσε $(4),"Μαγικός Αριθμός ";β.ΜαγικόςΑριθμός
Τύπωσε "Πίνακας τάξης ";β.Ν()
Τύπωσε β.Έλεγχος()
β.Α(2,1)++
Τύπωσε β.Έλεγχος()
β.Α(2,1)--
Τύπωσε β.Έλεγχος()


Αυτό εδώ είναι η παραλλαγή στο προηγούμενο έτσι η ΈλεγχοςΜαγικού() φεύγει και γίνεται απ' ευθείας Έλεγχος()
Επίσης η Σειρά() που ήταν αναφορά της Άθροισε γίνεται .Άθροισε() δηλαδή κλήση χωρίς αναφορά.
Την αναφορά την έβαλα για να δείξω ότι γίνεται! Δεν χρειάζεται όμως!

      Συνάρτηση Άθροισμα {
            καθαρο Σούμα
            Διάβασε Θχ,Θυ, Πχ, Πυ, Επ
            Για Επ=Επ-1 εως 0
                  Σούμα+=.Α(Θχ,Θυ)
                  Θχ+=Πχ
                  Θυ+=Πυ
            Επόμενο Επ
            =Σούμα
      }
      Συνάρτηση Ν {=Διάσταση(.Α(),1)}
      Συνάρτηση Έλεγχος {
            αν Διάσταση(.Α())=0 τότε έξοδος
            ν=.Ν()
            .ΜαγικόςΑριθμός<=.Άθροισμα(ν-1,0,-1,1,ν)
            οκ=αληθές
            για ι=0 εως ν-1
                  οκ=.Άθροισμα(0,ι,1,0,ν)=.ΜαγικόςΑριθμός και οκ
                  οκ=.Άθροισμα(ι,0,0,1,ν)=.ΜαγικόςΑριθμός και οκ
            επόμενο ι
            =.Άθροισμα(0,0,1,1,ν)=.ΜαγικόςΑριθμός και οκ
      }

Τρίγωνα!

Ένα απλό πρόγραμμα κατασκευής ορθογώνιου τριγώνου!
Θέλουμε το τρίγωνο να έχει υποτείνουσα 5000 twips (στον εκτυπωτή 1440 είναι η μια ίντσα, στην οθόνη είναι σχετικό αυτό και όχι απόλυτο, αν τις εντολές τις στείλουμε στον εκτυπωτή θα έχουμε όμως σωστό μέγεθος). Γωνία 0 είναι East (Ανατολή), και είναι σε ακτίνια (για να δουλεύουν ωραία με το Πι). Δείτε πως δεν βγαίνει τρίγωνο στο Πι/2.

Μπορεί  κανείς να χρησιμοποιήσει την Ομαλά Ναι για να έχει γραμμές χωρίς "δοντάκια". Αυτή η εντολή βάζει το GDI+ των Windows που είναι λίγο πιο αργή από το GDI32, αλλά έχει καλύτερα αποτελέσματα. (δουλεύει στις νεότερες εκδόσεις).

Φόρμα 60, 30 ' σε χαρακτήρες
Αναφορά 2, "Παράδειγμα Τρίγωνα", 12000 ' κεντράρισμα σε πλάτος 12000 twips
Τμήμα Τρίγωνο {
      Διάβασε α, β , γ
      θέση α, β
      Χάραξε Γωνία γ, 5000
      Χάραξε Έως θέση.χ, β
      Χάραξε Έως α, β
}
Για ι =πι/8 έως πι-πι/8 ανά πι/8 {
       Τρίγωνο 6000,6000,ι
}
Οθόνη , -5 ' χωριστή οθόνη στις πέντε τελευταίες γραμμές


Για να φτιάξω τη εικόνα παρακάτω έφτιαξα το β που κάλεσε το α, έφτιαξε το κάτω μέρος μεγαλύτερο και άνοιξε αυτόματα τον διορθωτή (μετά έκανα Print Screen από το πληκτρολόγιο και Paste στο Paint):
α
οθονη ,-15
σ α