Pour installer la dernière version de gambas sur des machines équipées de linux débian et autres variantes (mint,ubuntu,...) avec le système de paquet dpkg ou apt, il suffit d'écrire ces lignes dans un terminal :
Il est très important pour les utilisateurs ayant une ancienne version de gambas de bien supprimer la version actuelle avant l'installation de la nouvelle car la nouvelle version de gambas ne pourra pas fonctionner.
Aujourd'hui nous allons nous intéresser, pour ceux qui se souviennent de nos cours de math, des nombres complexes à utiliser en gambas.
nous voulons faire un simple calcul par exemple de deux complexes e = 4+5i et f = 24 -4i
Nous voulons simplement additionner ces deux nombres.
Voici comment procéder :
A) Ajout du composant gb.complex
Créez un nuoveau projet graphique et cochez dans les propriétés le composant gb.complex
B) Créez deux nombres complexes
Il vous suffit de définir dans une fonction deux nombres comme ceci
Dim e AsNew Complex Dim f AsNew Complex
Ensuite définissez les valeurs de chaque nombre par leur propriétés :
e.Real =4 e.Imag =5 f.Real =24 f.Imag =-4
C) Calcul réalisé, addition, soustraction, etc...
Dans une variable de type string, vous pourrez voir le résultat de l'addition par la commande:
Ici j'utilise simplement une messsagebox qui me renvoit un message de type string.
message.info(e+f)
D) Les autres méthodes
e.Abs2 retourne la surface en valeur absolue du complexe
e.Arg retourne l'argument du nombre complexe
e.Conj retourne le conjugué du nombre complexe
e.Copy retourne une copie du nombre complexe
e.Inv Retourne l'inverse du nombre complexe
e.ToString convertit un nombre complexe en chaine de caracteres lisible par l'homme du style 2+4i
Enfin la methode e.Polar() Crée un nouveau nombre complexe à partir de sons modulo et son argument. Si l'argument en deuxième position n'est pas spécifié, il est par défaut égal à 0.
Ceci n'est pas vraiment un article mais plutôt une piqûre de rappel d'une évidence que les nouveaux programmeurs ignorent ou dont ils ne tiennent pas compte car inutile pour eux et que certains anciens maltraitent.
Je vous renvoie vers un petit article de Gambix plus que pertinent : Nommage des variables.
Voici un bout de code pour suivre le nommage des variables et leur visibilité dans le code général du programme :
' Gambas class fileInherits TextBox '<--------------------------------------------------------- Tout l'héritage du composant TextBox'<----------------------------------------------------------------------------- (Export) pour créer la class dans l'IDE
Export
'<------------------------------- remarquez les doubles '' pour faire apparaître les commentaires en explication des objets dans l'IDEPrivate$value As Float ''Contient la valeur numériquePrivate$regPat AsString''Pattern des expressions réguliéresPrivate$format AsString''Contient le formatage de la variablePrivate$regex AsNew RegExp ''Contrôle l'entrée, il faut activer gb.pcrePrivate$bFocus AsBoolean''Boolean du focusPrivate$listview1 As ListView ''Le listview pour afficher et choisir l'expression régulièrePrivate$TextBox2 As TextBox ''pour afficher les informations sur les expressions régul.Private$lab As Label ''pour afficher le nombre formaté selon l'express. régul.PublicEnumsNumVirgule0, sNumVirgule1, sNumVirgule2, sNumVirgule3, sNumVirgule4, sNumVirgule' ne sert qu'à rendre les valeurs plus explicites dans le code' Static Public ind As IntegerPrivate$ListeC AsNewString[]'<-------------------------------------------- instanciation de la liste des formatsPrivate$ListeB AsNewString[]'<-------------------------------------------- instanciation de la liste des explicationsPrivate$Liste AsNewString[]'<--------------------------------------------- instanciation de la liste des expressions régulièresPrivate$obs As Observer '<-------------------------------------------------- les observer peuvent être déclarés en localPrivate$lvw1Obs As Observer '<---------------------------------------------- ou en global'<------------------- Début propriétés ajoutées à TextBox ---------------------PropertyValueAs Float ''Valeur float de la textboxPropertyFormatAsString''On passe le format que l'on souhaite voir en sortiePropertyTextRegAsInteger''On passe l'expression régulièrePrivateSubValue_Write(Value As Float) '<------------------------------------- la propriété Value de notre TextBox$value = Value '<--------------------------------------------------------- récupération de la valeur et transmision à la variable localeEndPrivateFunctionValue_Read() As Float '<------------------------------------- la propriété Value de notre TextBoxReturn$value '<---------------------------------------------------------- renvoi de la propriétéEndPrivateSubFormat_Write(sFormat AsString) '<------------------------------- la propriété Format de notre TextBox$format = sFormat '<------------------------------------------------------ récupération de la valeur et transmision à la variable localeEndPrivateFunctionFormat_Read() AsString'<--------------------------------- la propriété Format de notre TextBoxReturn$format '<--------------------------------------------------------- renvoi de la propriétéEndPrivateFunctionTextReg_Read() AsInteger'<--------------------------------- la propriété TextReg de notre TextBoxReturn$Liste.Find($regPat) '<---------------------------------------------- renvoi de la propriétéEndPrivateSubTextReg_Write(Value AsInteger) '<------------------------------- la propriété TextReg de notre TextBox$regPat =$Liste[Value]'<------------------------------------------------ récupération de la valeur et transmision à la variable localeEnd'<-------------------- Fin propriétés ajoutées à TextBox ----------------------PublicSub_new() '<--------------------------------------------------------- création et instanciation de tous les objets nécessaires' Dim $obs As Observer '<--------------------------------------------------- les observer peuvent être déclarés en local' Dim $lvw1Obs As Observer '<----------------------------------------------- ou en global qui les rend privéesDim sCste AsString'<----------------------------------------------------- variables locales pour alimenter le listviewDim i AsInteger'<-------------------------------------------------------- variables locales pour alimenter le listview$obs =New Observer(Me) As"obs"'<---------------------------------------- instanciation observer pour récupérer les évènements$listview1 =New ListView(Me.Parent) '<--------------------------------- instanciation listview d'affichage des expressions régulmières$lvw1Obs =New Observer($listview1) As"ListView1"'<---------------------- instanciation observer pour suivre l'évènement _Select$TextBox2 =New TextBox(Me.Parent) '<----------------------------------- instanciation textbox d'affichage d'explications$lab =New Label(Me.Parent) '<--------------------------------------------- instanciation label d'affichage du format
.../...
Le préfixe du nom d'une variable est donc une ou plusieurs minuscules suivies d'une majuscule, de mémoire je crois que cela s'appelle la notation Pascal mais bon l'important c'est de rendre la lecture de votre propre code facile à lire et intelligible.
En POO, la programmation orientée objet, on cherche à définir tous les objets dont dont va avoir besoin dans son programme.
Qui dois je définir en premier :
- la poule qui donnera un oeuf ou l'oeuf qui donnera une poule !
Car si l'oeuf est une poule en devenir l'oeuf ne l'est pas mais il contient un embryon qui lui est une poule en devenir.
Et, voilà de deux objets je me retrouve avec trois.
Et puis tous les embryons ne donne pas des poules et même tous les oeufs de poules ne donnent pas de poules s'ils n'ont pas été fécondés.
Et puis si c'est une poule mâle ça s'appelle un coq et ça ne pond pas d'oeufs.
Et puis tous les oeufs n'ont pas de de coquilles dures.
Et lors de l'instanciation, si je commence par la poule rien ne dit que j'aurais un oeuf, et si je commence par l'oeuf rien ne m'assure que j'aurais bien une poule et pas une chimère quelconque.
Et puis, de toutes façons, les rats m'ont bouffé tous les oeufs et tué toutes les poules.
J'ai commencé à programmer il y a bien longtemps sur des machines qui feraient hurler de rire vos chers téléphones portables.
J'en ai bien, un aujourd'hui mais il ne me sert que de téléphone.
Mon premier programme en assembleur m'a pris un mois d'écriture pour faire défiler un "bonjour, madame" sur la ligne écran de mon Z80, c'était en 19.. (de quoi je me mêle ?).
Ensuite je suis passé à un commodore 64, il avait tellement peu de mémoire que pour faire tourner un programme (en basic 16 bits, si madame ça a existé) il fallait découper le dit programme en morceaux que l'on chargeait un par un, en mémoire après avoir vidé celle-ci, du morceau précédent.
Pourquoi je disais ça, faut dire que si vous n'arrêtez pas de m'interrompre tout le temps, je perds le fil, moi.
En fait en arrivant sur Gambas, mes premiers programmes étaient aussi peu rangés que ma chambre si ma femme ne passait pas, derrière moi.
En lisant des articles et des programmes commentés je me suis aperçu qu'ils étaient faciles à suivre et comprendre parce qu'ils étaient aérés et commentés.
En lisant un code d'un certain Cogier, cherchez ses productions sur la logithèque de Gambas, chaque ligne était commentée et la présentation était soignée, les commentaires tirés au cordeau, toujours à 81 caractères sur la ligne (ce qui correspond à plusieurs tabulations, vous les compterez) ce qui rendait le code attractif, facile à lire et compréhensible.
Depuis je me suis imposé ce travail qui de fastidieux est devenu une autre chose, très intéressante, cela m'oblige à relire mon code, à améliorer celui-ci et surtout les commentaires pour qu'ils soient les plus explicites possibles, en peu de place.
Et, ce faisant vous vous rendrez compte des évolutions de vos propres pensées et de la structuration de celles-ci et donc de l'apport indéniable des commentaires dans vos programmes.
Car vos commentaires sont la traduction de vos pensées et non une simple traduction de texte, sans aucune valeur.
Alors n'hésitez pas, commentez vos codes, d'abord pour vous même et ensuite .. pour vous même car les autres suivront.
PublicSubCommand(Command AsString) AsString'Takes the Command and returns the output of the commandIfNot Command ThenReturn'If
there is no Command thenget out of here!
sCommand = Command 'Move the Command to a global variableIf sPassword Then'If the password has been stored then..
ButtonAuthenticate_Click 'Click the 'Authenticate' buttonReturn sOutput 'Return the Command's outputEndIf
LabelHeader.text = ("Authentication is required to run this programn'")
& Command &"'"'Add a notice and the name of the command to be
run
CheckCapsLock 'Check if the Caps Lock is onMe.Showmodal 'Show the Authentication FormReturn sOutput 'Return the Command's outputEnd
PublicSubobs_Change() ''Contrôle de la saisieIfMe.text Then'<--------------------------------------------------------- pour ne pas avoir d'erreur de texte vide$regex.Exec(Me.Text)
'<--------------------------------------------- test de la valeur au
crible de l'expression régulièreMe.Text =$regex.Text '<--------------------------------------------- isNumber() donc on récupère chaque chiffreIfMe.Text Match "."ThenMe.Text = Replace(Me.Text, ".", ",") '<----- pour récupérer la virgule à partir du pointIfMe.text Then$value = Val(Me.Text) '<----------------------------- si j'ai du texte alors j'ai une valeurIfMe.Value >999999999.99Then'<------------------------------------- pour ne pas dépasser la sommeMe.Value =0'<------------------------------------------------- la valeur est remise à zéroMe.Clear '<----------------------------------------------------- le texte est effacéMe.SetFocus '<----------------------------------------------------- le focus est remis au champ$lab.Text =""'<------------------------------------------------- le label d'affichage est effacéEndifElse'<----------------------------------------------------------------- si le texte n'est pas alimenté alors$value =0'<--------------------------------------------------------- s'il n'y a pas de texte alors la valeur = 0$lab.Text =""'<----------------------------------------------------- et on vide le texte du labelEndifIfMe.Text AndIf$format Then'<----------------------------------------- si le texte et le format sont alimentés alors$lab.Text = Format(Val(Me.Text), $format) '<------------------------- affichage dans le label selon le formatEndifEnd
Bonjour, me voilà promu rédacteur, ça fout les chocottes mais c'est sympathique de faire vivre notre passion et de l'animer.
Aujourd'hui, je n'ai pas de code, d'exemple à vous transmettre mais je vais profiter de cet instant pour faire la promotion d'un logiciel qu'on trouve dans la logithèque de Gambas ( afficher les filtres et dans les étiquettes : CD) qui se nomme gbTranslate.
Il est en version 1.2.5, actuellement et son auteur est Claude Desseré.
Il permet de faire vos traductions d'une façon légèrement différente de celle de l'IDE de Gambas ; il ne vient pas en concurrence mais bien en complément et même en remplacement lors des traductions de très gros fichiers.
