Reprise du message précédent :

 
EDIT : Pour dessiner dans le canvas il faut passer par le paint-callback ou c est le canvas et e l'environnemt.
Un truc du style
(paint-callback  
     (lambda (c e)  
         (let ((dc (send c (get-dc))))
           (send dc clear)
           ...)))
 
RE-EDIT : La prochaine fois fait un topic carrement.

PETITE question de GROS débutant :
Je ne suis pas un As de la prog mais pour mon boulot, j'ai du me mettre au Scheme. En effet, je bosse sur le logiciel de CFD Fluent, et j'ai vu qu'il est possible de créer des menus, fonctions, etc... personalisées dans fluent à l'aide de fichiers scheme.
En faisant des cop/col de barbare j'arrive dejà a faire tourner des petites interfaces graphiques, mais ca reste tres limité.
Ce WE je tombe sur votre post, et là je me dis : sauvé, à moi la maitrise de Scheme... et ce matin (lundi) : cacahuete!! j'essaie de lancer les lignes de codes de base pour créer une fenetre (define splash etc...) et je me prend un message d'erreur dans la tête
comme promis la question :
-->est-ce que quelqu'un sait d'ou ca vient? faut-il installer une librairie speciale ou la fonction 'instantiate' est definie? et encore mieux : est-ce que quelqu'un connait les fonctions prédefinies de Fluent utilisables dans un fichier scheme? (les coquinous de chez Fluent ne diffusent aucun doc officiel sur la prog en Scheme).
 
Merci et à bientôt!

Alors si t'as copié-collé le splash expliqué précédemment et que ca marche po !
A mon avis c que T po dans le bon langage ...
Il faut aller dans langage, selectioner le langage et choisir le langage graphique MrEd ...
Si ca marche tjrs po alors la ... :S

 
Le pb c'est que sur mon Pc ca marche (j'utilise DrScheme pour compiler). La je suis au boulot, et je dois rentrer mes lignes de code dirrectement sous Fluent. Je n'ai aucune info sur le langage utilisé, je sais simplement que c'est du Scheme.
Je ne crois pas pouvoir changer les options de langage graphique    
pour créer mes interfaces, j'utilisais jusqu'alors les fonctions prédefinies de fluent, mais comme fluent est tres tres avare en doc sur les fonctions scheme, c'est difficile de faire tout ce que l'on veut avec.... c'est pour ca que j'aimerais connaître les fonctions basiques pour faire apparaitre une fenetre, des bouttons, etc...

Bonsoir,
 
Je crois que Babar512 a raison, le code que tu vois est spécifique à Drscheme: il utilise ses librairies "natives". Donc, au boulot, tu ne pourras pas l'utiliser.  
 Autrement, j'ai vu le site de fluent qu'ils utilisent Gambit comme implémentation scheme. Renseigne toi dessus, si c'est cela que tu utilises. Sinon, il te reste à utiliser la glue avec des programmes annexes et reporte-toi au post de Chronoklazm sur la conversion scheme->C. Tu auras certainement des indices pour lier tes prog.
   Cela étant, cela relève d'une question que l'on s'était posé au départ Il y a-t-il des volontaires pour faire des interfaces graphiques avec d'autres bibliothèques.
Merci à tous et à bientôt. nous faisons de notre mieux pour faire avancer cet annuaire.

Au risque de paraitre le plus chiant du monde je vais vous demander un petit service :
pourriez vous m'ecrire qqs fonctions qui permettent :
d'ouvrir une fenetre avec une image, et un bouton, et lorsque'on clik' sur le bouton, une autre image apparait sur la premiere image (ou a la place a la limite) !!!
Ce serait fort sympatique de votre part : j'ai l'impression de pédaler dans la choucroute ....

 
Tout d'abord merci de vous etre penché sur mon cas ceci-dit, quand on parle de Gambit sous fluent, il s'agit de son Préprocesseur pour effectuer du maillage en volumes finis... Je sais qu'il existe une implementation de Scheme nommée Gambit, mais (helas) je crois que les 2 Gambits n'ont rien à voir...  
Je vais quand meme creuser la question!
 
Sinon pour info, j'ai ouvert un post [Scheme for Fluent] ou j'invite les utilisateurs de Fluent à partager les infos qu'ils ont récupérés sur la librairie de Scheme propre à Fluent.
 
A bientot, et encore merci!
 
Ah oui... juste une question : si Fluent utilise une librairie scheme qui lui est propre, j'imagine que cette fuckin' librarie est definie quelquepart sur mon IBM? si oui, pensez-vous que de trouver la source et de l'ouvrir peut ml'aider à comprendre des fonctions?

 
Il n'y a rien de plus simple ! Mais fait un topic stp si t'a d'autres questions sur ton projet.
 
------------------------------------------------------------------------------
(define fenetre (instantiate frame%
                   ("---~~~~oooOOOO NAVAL BATTLE OOOOooo~~~~---" ) (parent #f)
                   (width 400) (height 400)))
 
(define cadre1 (new horizontal-pane% (parent fenetre)(border 5)(spacing 2)))
 
(define cadre2 (new horizontal-pane% (parent fenetre)(border 2)(spacing 2)))
 
(define canvas1 (instantiate canvas% (cadre1) (style '())))  
 
(define canvas2 (instantiate canvas% (cadre1) (style '())))
 
 
(define test1 (make-object bitmap% "test1.gif" 'gif #f))
(define test2 (make-object bitmap% "test2.gif" 'gif #f))
 
(define Tirer (new text-field% (parent cadre2)  
                    (label "Tirer" )
                    (callback (lambda(text-field control-event)(void)))
                    (init-value "" )(style '(single))(enabled #t)  
                    (vert-margin 2)(horiz-margin 2)))
 
(define temp #f)
(define bouton (new button%(parent cadre2)( label "bouton" )  
                              (callback(lambda(button event)  
                                         (let ((dc1 (send canvas1 get-dc))
                                               (dc2 (send canvas2 get-dc)))
                                           (if temp
                                               (begin
                                                 (send dc1 draw-bitmap test2 10 10)
                                                 (set! temp #f))
                                               (begin
                                                 (send dc1 draw-bitmap test1 10 10)
                                                 (set! temp #t))))))))  
 
(send fenetre show #t)
 
-----------------------------------------------------------------------------------
 
Les images :
 - test1
 - test2

La chronoklazm, j'te remerci grave pour c'ke tu m'as fait ...
Ca va bien m'aider ....
Et promis, je vous embeterai plus ici avec ma bataille navale...
ou peut etre pour vous la poster, quand elle sera finie
Une fois que j'aurai bien compris le coté graphique de scheme ... je vous aiderai pour votre super-agenda de la mort ...
merci ++

il a pollué plein de topics cet animal, j'ai du tout effacer

Merci !   .

Bonjour à tous,
 
 Vu que cela fait un petit bout de temps que nous n'avons rien fait de nouveau, le temps est compté pour tous, je vais vous proposer un petit morceau de code: il s'agit d'envoyer dans les différents champs les résultats d'une recherche, soit par le nom, soit par le prénom, soit par ce que vous voulez, vous pourrez implémenter. Ce n'est pas de la haute voltige, mais ça a le mérite de fonctionner.
 tout d'abord, il vous faudra rajouter dans le "agenda-core.ss" la ligne suivante :  
(require (lib "13.ss""srfi" ))  
qui nous propose des fonctions toutes faites pour les strings.
   Ensuite, moi j'ai rajouté un boutton "essai", car j'ai bien mettre le bazar, qui appellera notre fonction. En voici la définition:
 
;boutton essai                                      
(define essai (new button%  
            (parent horiz-panel)
            (label"essai")
            (callback(lambda(button event)
                (give-tout ; notre fonction
                   (string-upcase(send nom get-value)) ;comme vous l'avez constaté, il faut jouer avec les majuscule pour envoyer la recherche(make-personne 'DUPUIS): ce n'est plus le cas, on le fait pour vous
                    (string-titlecase(send prenom get-value)) ; la première lettre du prénom est en majuscule en général. On le fait encore pour vous
                     (send adresse get-value))))
                   (style '())(enabled #t)
                    (vert-margin 2)(horiz-margin 2)))
 
Maintenant, la fonction give-tout:
 
;essai de fonction qui renvoi tout sur avec le nom dans le text
(define (give-tout nom1 prenom1 )
    (for-each(lambda (x) (if [or(equal? (personne-nom x) nom1)
                                 (equal? (personne-prenom x)prenom1)]  
                            (begin(send nom set-value (personne-nom x))
                                  (send prenom set-value (personne-prenom x))
                                  (send adresse set-value (personne-adresse x))
                                  ); si #t
                            (void)))
              annuaire))
  Vous pouvez rajouter le reste des champs. Si vous voulez faire une recherche par le numéro de tel, il y a un piège. La soluce à la prochaine. Quand tout sera prêt, vous n'aurez plus rien à faire. Pour l'instant on essaye "pédagogie" .
A bientôt.

Bonjour tout le monde.
 
 Nous cherchons encore pour vous proposer une fonction de recherche évoluée. Pour vous faire patienter, voici un petit fichier "main.ss" qui permettra de lancer l'application sans avoir à charger 25 fichiers.
 

 
Il faudra aussi faire un eu de ménage dans les "agenda-core", "agenda-gui" ainsi que "splash_screen":  enlever tout les (require(lib....) et les (send splash show #t)et(send principale show#t), le fichier main s'en charge dorenavant.
A+ pour de nouvelles aventures.

Bonsoir,
 
  Toujours pour vous faire patienter, voici un nouveau petit bout de code. Celui-ci, va parcourir notre liste et vérifier si un nom existe dans notre liste et nous permettra de faire toute la liste (vérification d'homonymie). Ce code ne s'intègre pas encore dans notre interface graphique, mais vous rendra peut-être bien des services. Attention, ici, on change de style.
 
 D'abord, un petit retour sur les structures : Lorsque nous définissons une structure, nous créeons dans le même temps un constructeur et différents sélécteurs. Par exemple (define-struct personne (nom prenom tel)), crée un constructeur: make-personne, et trois "sélécteurs" (accesseurs ?): personne-nom, personne-prénom et personne-tel. Et nous rappelons que "personne" est une structure (structure? personne) devrait vous retourner #t.
 
 D'autre part, nous savons que les listes peuvent contenir des symboles, des nombres et aussi...des structures. Au sein de ces listes, les accesseurs sont utilisables. Donc, nous pouvons utiliser ces que nous savons des listes pour parcourir notre agenda.
 
ex: Nous cherchons si untel existe dans notre agenda. Jusque ici, lorsque nous parcourions notre liste, la fonction s'arrêtait dès que la condition était requise. Mais en cas d'homonymie, on tombera toujours sur le premier (donc pas le tel de tante Marthe puisque celui de tonton André a été saisi en premier. Il vous reste, je crois, soit les call/cc, soit le CPS (à moins que je ne me trompe).
  Et bien, la recurssivité sur les listes va nous servir:

 
Vous pouvez donc le lancer (contient? "DUPUIS" annuaire). Attention, l'argument cherché est une chaîne de caractère, n'oubliez pas les guillements.  Vous pouvez intégrer ce code où vous voulez. Si il y a des messages d'erreurs, vérifiez l'ordre d'évaluation de vos fichiers. Je m'explique: si vous avez recopié mon "main.ss" tel-quel et que vous copiez cet exemple dans "agenda-core", raté. Il vous faudra inverser "agenda-gui.ss" et "agenda-core.ss" dans le main.
 
  Maintenant, crééz une fonction basée sur le même principe qui retourne un doublet (nom . prénom) et ce, pour toute la liste. Sept ligne, pour cette fonction, ça arrache, non? Mais méfiez-vous, il m'a fallu une semaine et énormément de doc pour la pondre celle-là. Allez entraînez-vous avec ce style  et n'hésitez pas à demander.
A bientôt.

-----------------------------------------------------------------------------------------------
Bon allé petit up !  
 
(J'ai pas le trop le temps pour l'annuaire mais le le_courtois assure bien de ce coté là en ce moment)
 
Sachant que le but de ce topic est de montrer les differentes choses qu'on peut faire dans Scheme, voici un petit exemple tout bête de la fonction qui calcule la factoriele en simulant la forme speciale letrec (ze variante de boucle universelle, y a une forme encore plus poussée que je montrerai bientot ).
 
Voila comment on aurais fait AVEC le letrec (version recursive enveloppée):
 
(define (fac-letrec n)
   (letrec ((loop (lambda (m)
                    (if (zero? m)
                         1        ; 0! = 1
                         (* m (loop (- m 1)))))))
     (loop n)))
 
(fac-letrec 3)
=> 6
 
Voila donc rien de bien compliqué, on a une fonction recursive locale "loop" (qui est une lambda) ce qui est autorisée UNIQUEMENT GRACE au letrec et l'appel recursif est envellopé, ce genre de magouille est impossible avec un simple let.
 
MAIS il existe un moyen d'esquiver cette interdiction grace à ... une lambda bien placée biensur C'est une technique ou plus precisement un style : le CPS ce qui veut dire Continuation Passing Style, sous ce terme assez deroutant ce cache toute une strategie d'utilisation de la lambda ... je m'arrete la puisque les vraies continuations seront expliqués un peu plus tard (la prise du controle absolue n'est pas pour tout suite ).  
 
Voila comment on aurais fait avec un simple let (version cps):
 
(define (fac n)
  (let ((fuk (lambda (n k)
               (if (= n 0)
                   1
                   (* n (k (- n 1) k))))))
    (fuk n fuk)))
 
(fac 3)
=> 6
 
fuk est une lambda à 2 parametres (n et k) ou k est la continuation courante.
Au premier regard on se dit que dans la premiere version on aurait pu simplement remplacer le letrec par un let et basta, mais il n'en est rien car ca ne marchera pas.
Ici la lambda fuk n'est pas une fonction recusive locale c'est un espece d'emboitement de lambdas mais ou l'allocation de la memoire n'est pas faites sur la pile mais sur la memoire du tas ! Attention dans certains cas on a des gains de performances assez significatifs par rapport a une simple recusivité, mais ce n'est absolument pas garantit pout tous les cas.
En d'autres termes c'est un moyen de "espacer" ou "applatir" les appels recursifs.
 
Voila si vous trouvez que je n'ai pas été assez clair precisez le !
 
EDIT : je donnerai quelques details sur le CPS plus tard.

Et il faut que je passe après ça    ? Je vais passer pour quoi moi?
 
 Bon, faut s'y coller, Bonjour tout le monde.
 
 Ce que je vais commencer à vous proposer est une version possible avec les vecteurs. Attention, on change de style. Programmez avec le mien et vous êtes certains d'avoir vos exams...reportés en septembre  .
  Pourquoi ce changement. Tout d'abord, celui-ci est temporaire, Chronoklazm est en exams et moi, il y a certaines choses que j'ai du mal à saisir avec les structures. Je me sens plus à l'aise avec les vecteurs. Et le but du jeu est de vous faire faire un tour de ce qui est possible en scheme et vous puissiez choisir ce qui vous convient le plus.
 
  Quelques modifications seront nécessaires, mais je suis persuadé qu'avec ce qu'il vous a été dit précédement, vous allez être largement capables de le faire. Faites un nouveau reprertoire avec tout ce qu'il faut dedans (agenda-gui) et faites un nouveau fichier main et nous allons créer un nouveau fichier par ex "vect_annu.ss".
 
   Nous allons commencer par créer un ficier data.ss dans lequel nous rangerons nos données simplement sous forme de vecteur : #("DUPUIS" "Jean" "123" ). Mettez en plusieurs, ce sera mieux. Pourquoi comme çela? Simplement parceque je n'ai pas implémenté de fonction qui vérifie l'existence du fichier et qui le crée sinon (spa bien, je sais).
  Nous avons nos données, il nous faut construire l'annuaire en les chargeant:
 
(define annuaire
  (call-with-input-file (build-path "/votre_chemin/data.ss" )
    (lambda (p)
      (let loop ((line (read p))
                 (result '()))
        (if (eof-object? line)
            (reverse result)
            (loop (read p) (cons line result)))))))
 
 On vient de créer une liste de vecteurs. A l'instar des structures, les accesseurs des vecteurs sont valides à l'intérieur de cette liste. Notre base est donc créee. D'accord, nous chargeons tout en mémoire, mais le but de cet agenda n'est pas d'enregistrer l'adresse et le tel de tous les atomes de plomd présents sur cette terre.
 
   Recherchons à présent si un nom existe dans l'annuaire. Mais nous allons vous proposer de pouvoir rechercher soit par nom, soit par prénom ou par telephone.  Ben oui, un papier qui tranîne avec juste le téléphone ça n'arrive jamais ! Ici, nous allons biaiser. Imaginez votre "base de données sous forme de tableau: la colonne 0 les noms, la colonne 1, les prénoms,... Nous allons donc rechercher dans la colonne correspondant à votre critère de recherche. ex tapez (vector-ref (first annuaire)0) vous devez obtenir "DUPUIS". Magique. Voici le code:
 
; recherche si nom existe et reconstruit un vecteur
(define(contain? name x an-annu)
(cond
    [(empty? an-annu)empty]
                   [else(cond
                          [(equal? (vector-ref(first an-annu)x) name)
                        (cons(vector(vector-ref(first an-annu)0)(vector-ref (first an-annu)1))(contain? name x(rest an-annu)))]
                          [else(contain? name x(rest an-annu))])]))
 
Ici, le x va nous servir avec l'interface graphique, puisque nous allons y ajouter une radio-box qui vous demandera votre critère de recherche. On prendra la valeur du bouton coché qui déterminera dans quelle colonne chercher. Je reconstruit ici un vecteru et non une liste car j'aimerais pouvoir avoir encore accès à mes accesseurs directs lors d'une prochaine fonction. Comme vous le voyez, cette fonction me retourne toutes les solutions de ma requête. En cas d'homonymie, j'a bien la liste de tout ceux qui portent le même nom. Qu'en faire. Ce sera le but de la prochaine fonction. Je ne l'ai pas encore terminée, mais je vais vous présenter ce que je veux qu'elle fasse. C'est cette fonction qui sera appelée par le boutton recherche de l'interface graphique.
 
(define (trouver2 name x)
  (let((a(list(contain? name x annuaire)))
 
   Déjà comme cela elle vous retournera sur votre console la liste de votre requête. On verra un peu plus bas. Ce que je vais lui demander à cette fonction,c'est de vérifier la longueur de la liste a. Si elle est égale à 1, j'envoie les résultats dans mes champs. Si elle est sup à 1, il y a donc plusieurs occurences du même nom. Je lui demanderai donc de vous envoyer le choix. Si longueur de la liste = 0...
 
  Maintenant, passons à l'interface graphique. Ajoutons le radio-box:
 
 
(define radio-rech(new radio-box% (label"Choisissez votre critère de recherche")
(choices'("Par nom""par prénom""par telephone"))(parent vertical-panel2)
(callback (lambda(radio-rech control-event)(void)))(style '(vertical))))
 
  Le radio-box renvoie 0 pour le choix 1, 1 pour le choix 2,...Ca tombe bien notre "champ"  nom est le (vector-ref vecteur 0). Et en plus les fainéants ont de la chance. Pour notre interface, nous aurons juste à trouver la bonne valeur de x pour le telephone, mais un (+ n x) qq part devrait suffire.
 
  Maintenant ajoutons à notre boutton essai (ou recherche, moi je reste avec essai jusqu'à la fin et après je renommerai le tout). Ca nous donne:  
(...)
(callback(lambda(button event)
          (trouver2(send nom get-value)(send radio-rech get-selection))))
 
  Voilà pour ce soir. La semaine prochaine, même si je n'ai pas eu le temps de finir la fonction trouver, je vous dirai comme incrémenter le fichier data.ss avec vos données.
  N'hésitez pas à poser des questions, commentaires,... et bon courage. Attention sur la route pendant le week-end. Salut!
 
Edit: Oups, dans la précipitation, je n'avais pas fait gaffe. Dans l'appel à la fonction trouver2 il faudra faire un tri en amont. Je m'explique: là nous avons un (send nom get-value), ce qui ne fonctionnera pas si vous cherchez par un prénom. Donc exo1: faire un tri pour que la fonction recoive bien la valeur du champ recherché. Un case ou un if devraient suffire. Et on ne critique pas ma façon de faire SVP   . J'ai jamais appris comment faire bien   .

Edit 2: Finalement, on va pas attendre, voici la correction pour l'envoi à la fonction trouver2 :
(...)
(callback(lambda(button event)
 (let ((x (send radio-rech get-selection)))
                                           (case x
                                             ((= 0)(trouver2(string-upcase(send nom get-value))x))
                                             ((= 1 )(trouver2(string-titlecase(send prenom get-value))x))
                                             ((= 2)(trouver2(send telephone_fixe get-value)(+ 4 x)))))))
                                         (style '())(enabled #t)
                            (vert-margin 2)(horiz-margin 2)))
 
Dans le dernier cas, le (+ 4 x) correspond à la valeur du vector-ref pour accéder au numéro de telephone fixe tel que donné dans l'exemple complet (avec tous les champs). (C'est le 6ème champ et comme x=2 dans le radio-box...).

Bonjour,
 
  Histoire de vous faire patienter un peu, nous allons continuer doucettement. J'avais promis de faire la fonction (enregistrer) histoire de faire progresser le nombre de vos adresses disponibles. Le code est vraiment pas beau, mais j'avais envie de le faire comme cela. Vous verrez lors de la fonction d'affichage que l'on s'y prendra autrement.
 
Voici la fonction:

 
Voilà, il n'y a plus qu'à entrer vos données et de les enregistrer. Pour l'instant, cela ne prend pas en compte les fioritures que vous auriez pu mettre dans le champ texte. Je vais me pencher dessus.
 
  Maintenant, passons à l'affichage. il n'est actuellement possible qu'en cas d'un seul nom correspondant à vos recherches. D'abord quelques modifications: le radio-box à changé de panel. Je l'ai mis avec les bouttons, tout en bas. Donc changez le "parent" en (parent horiz-panel).
 Deuxième changement, l'éditeur est passé dans un panel :  

 
 Je sais, beaucoup de changements, mais bon, on apprend.
 
  Alors pour faire l'affichage des données, quelques petites fonctions annexes ont été crées:
 D'abord, la fonction (trouver2):

 Elle nous retourne une liste de vecteur, construite par (contain?). Au fait, elle est modifiée également. Au lieu de construire que le nom et prénom comme dans le dernier post, je construit avec tous les (vector-ref)de nos champs (il y en a 9). Donc cette liste est "longue" de 1 si un seul enregistrement du critère de recherche est trouvé, plus si...plus,etc. Si 1 on appelle la fonction (ecrire) qui prend un argument: la liste a créée.
 
  Afn d'aller plus rapidement et de ne pas être obligé de prendre les champs un par un pour les remplir, j'ai construit ceci:
 

  Cela nous construit une liste de tous les text-field% présents. Sauf l'éditeur de texte,lequel a d'autres méthodes, incompatibles avec notre future automatisation de l'envoi des données.
 
  Maintenant, la fonction (ecrire):

 Si vous avez besoin d'explications, demandez.
 Alors, qu'en pensez-vous? Ne vous inquiétez pas, une fois tout fini, on récapitulera tout en faisant un peu de ménage.
 
   Par contre, nous aimerions bien avoir des aperçus de vos impressions SVP.
A+
 
Edit : Allez, faut pas pousser, je vais quand même remplir la condition 0 en cas de recherche de nom. Tout simple:
  Dans la fonction (trouver2), changer la ligne où b=0 comme ceci:
 
((= 0)(message-box "Désolé" "Aucune personne trouvée avec vos critères" principale '(ok)))
 
C'était vraiment pas compliqué, alors pourquoi s'en priver?

Salut,  
 
C'est nikel tout ca
 
Ca serai cool si tu pouvais balancer tout le code (si c'est pas ici alors peut etre sur http://img179.exs.cx sous forme d'un fichier .txt (ou meme .scm) que tu auras renommé en .jpg ou une bidouille du genre ...

Salut,
 
 Je pensais récapituler le tout lorsque la majorité des fonctionnalités sera implémentée. Il reste le cas de plusieurs réponses, la modification d'un enregistrement existant, pour que ça commence à tenir la route.
  Et puis, j'attendais des commentaires sur le code, j'étais pas certain qu'il soit "acceptable". Et pourquoi pas faire les deux: sur ce forum et à l'adresse que tu m'a indiqué. Franchement, ça ressemble à quelque chose ou pas?
 
 Donc, j'avance encore un peu et je balance. Finis les partiels?

Oui et non, aujourd'hui partiel (en attendant la rafale en juin) et hier 3ieme projet surprise ... pour nous occuper un peu quoi.
 
Sinon oué carrement que ca ressemble à qq chose des que tu le peux balance une beta pour qu'on la teste.

je sais pas si vous avez entendu parler
http://www.helsinki.fi/~pakaste/lukutoukka/
ça me donne méchemment envie de refaire du scheme quand je vois le résultat. Et puis le soft est marrant à utiliser

J'ai pas capté l'interet du soft ... mais toutes les raisons sont bonnes pour faire du Scheme

     
Ca, ça motive. J'essaye avant la fin de la semaine du week-end. Bonne nuit et m***e.
 
Edti: Wahou, le lien et pis glade + scheme   J'en rêvais. MAis bon, pas ce soir  

Bonsoir tout le monde,
 
 A mon tour de vous mettre à contribution. Voilà mon souci: il me reste à implémenter (entre autre) le cas d'homonymie lors de la recherche. Le problème c'est que je ne sais pas sous quelle forme le signifier à l'utilisateur. Je ne veux pas d'une simple boîte d'alerte, ni d'un listing exhaustif genre "maintenant débrouillez-vous", ni de "donnez-moi plus d'info",...
  J'avais pensé à une radio-box ou une liste-choice mais voilà elles n'acceptent que des "proper list" et me refusent ma liste en argument.
  Ce que je voudrais, c'est présenter succintement les différents choix et qu'en un click, l'utilisateur voit s'afficher dans l'interface principale l'intégralité de la séléction.
 
  Sinon, dites-moi comment vous voudriez que l'on vous alerte ou ce que vous voudriez que l'on vous propose dans ce cas? Ah oui, le premier qui me parle d'une sorte de complétion automatique à choix multiple au fur et à mesure de l'écriture dans le champ, aura affaire à moi.
 
 Là, franchement, je sêche un peu. Ais-je été clair dans ma demande? Merci de votre aide. A bientôt.
 
Edit: Tout ça comme idées? Bon,à l'unanimité, ce sera une liste-box qui disparaitra après le clique de choix. Me reste à créer la liste qui fera office de choix.

Ah y'est !!    
 
  Bonjour tout le monde. Ceci, juste pour vous dire que la première version de test en terminée. Vous pourrez enregistrer vos données, rechercher par nom, prénom et n° de tel. En cas d'homonymie, une petite list-box vous permettra de choisir l'interlocuteur désiré.
 
  Je posterai ce soir, peut-être assez tard (plutôt à partir de 22 heures).
A ce soir donc.

Version finale du 18 juin 2005
 
  Voici la version, que j'espère finale. Si vous avez déjà enregistré la version précédente, reprenez ce qui suit, car tous les fichiers ont un peu évolués.Vous pourrez, avec cet annuaire, enregistrer de nouvelles fiches (normal), en supprimer et envoyer un courriel  de manière très simple.
 
  Si le code vous paraît un peu décousu, c'est normal, chaque fonction a été faite pour que vous compreniez au mieux ce que j'ai tenté de faire et pour qu'elles puissent être réutilisées. Une sorte de modeste cookbook.
 
  Afin de récupérer le code, cliquez sur l'icone "éditez le texte", faire un copier/coller dans votre interpréteur favori et voilà. J'ai essayé de faire simple. Ce qui est intéressant, c'est qu'avant de commencer ce topic, je ne savais faire guère plus que la définition de la fonction carré. Si ça peut motiver qqn qui rame.
 
Le fichier "main.ss". Celui que vous devrez exécuter pour lancer le tout:

 
Le splash-screen. Mettez l'image que vous voulez(je sais pas comment en mettre une ici):

 
  Une petite interface qui vous permet de configurer le programme pour vos envois de courriel. Il est appelé à la première utilisation (vérifiée par la présence ou non du fichier "data.ss" ). Sinon vous pouvez l'appeler dans le menu Fichier:

 
L'interface graphique. Le plus gros morceau, pour l'instant (vous pouvez en refaire une sur mredesigner si vous voulez):

 
Le côté fonctionnel de toutes ces belles choses:

 
  Un peiti fichier qui vous permettra d'éditer et d'envoyer des courriels :

 Voilà. Revenez me dire ce que vous en pensez. Si je peux me permettre: J'suis qd même rudement content d'en être arrivé là....et....hop  
 
Edit1 : Ah oui aussi, l'annuaire ne se recharge pas automatiquement, il faut relancer le tout (pas à chq fois, qd vous avez fini). Il n'est pas possible de modifier directement, mais vous devriez y arriver facilement. Si les demandes sont élevées, je tâcherai de m'y coller. Si vous voulez modifier, vous ouvrez votre feuille, vous la supprimez, vous corrigez et enregistrez. Amusez-vous bien.

Bonsoir tout le monde,
 
    Alors, c'est bien, c'est nul, des soucis ??? N'hésitez pas à poser des questions, ça vous intéresse ???
 
  Si y'en a des qui veulent émettre des suggestions afin de combler ce qui manque, allez-y. Moi, je risque de mettre un peu de temps avant de le faire. Ou alors vous êtes patients. Dites quelque chose...svp    
 
 Bon ben bonne nuit à tous. Ce n'était pas un up déguisé, mais une pêche aux infos.
 
Edit: dites-moi qqchose ou je tue le chien !  

 Le chien est mort!    
 
  Bon, quelques petits éclaircissements pour la suite. Le code final n'est pas encore prêt, mais je vais tenter de vous expliquer comme je le conçoit. Et puis si qqn veut s'y coller...
 
  Voilà, on veut effacer un nom du répertoire. Personnellement, je voulais créer une fonction qui effacerait directement sur le fichier sans avoir à le réecrire sans cesse. D'autant plus si par hasard une personne voulait l'utiliser et le remplissait de qq centaines de noms, les réecrire à chaque changement prendrait du temps. Mais bon, je n'ai pas réussi. Alors nous allons agir autrement.
 
 Agenda est une liste, donc il nous faudra enlever le nom désiré de la liste, actualiser celle-ci et l'enregistrer sur le fichier. Voici un exemple de base:

 
 La librairie "list.ss" nous propose cette fonction (remove item liste). Vous pouvez mettre, dans notre exemple, soit 1, soit 2, soit 3,...et c'est cet élément qui va disparaître.
 
 Une fois la line enlevée, il ne nous restera plus qu'à écrire les éléments de la liste (et non la liste si nous voulons garder nos vecteurs). Vous venez d'avoir le principe, il reste la réalisation. Si vous avez d'autres idées, n'hésitez pas à nous en faire part.
 
 A bientôt.

Bonjour à tous,
 
  Voici la fonction "Supprimer". Finalement, je ne me suis pas trop cassé la tête: On va prendre, à l'instar de la fonction "Enregistrer", le contenu de tous les champs, on en crée un item de liste en bonne et dûe forme que l'on soustrait à la liste annuaire et nous remplaçons le fichier data.ss avec les nouvelles données.
 
  Comme précédemment, il faudra relancer tout le programme pour que ce dernier prenne en compte le changement. Avec, cette fois-ci, l'avantage que si vous vous rendez compte que vous n'avez pas effacé le bon fichier, il ne vous reste plus qu'à aller le rechercher et à l'enregistrer de nouveau.
 
  Je vous laisse le soin de mettre le boutton supprimer dans l'interface graphique. Je sais, c'est pas très beau (et je trouve que ça va de mal en pis) mais ça fonctionne:

 
  Pour rappel, pour énumérer les constituants d'une liste:

 
  Alors si qqn veut faire un petit qqchose qui nous informerait sur le temps mis pour trouver un mot dans la liste et le temps mis pour l'afficher, je suis preneur.
 Encore une fois n'hésitez pas avec vos commentaires (ou améliorations) et éventuellement sur vos désidérata. A+
 
Edit: Ah oui! Il n'y a pas de boîte d'alerte. Pourquoi? Un parce que j'imagine que vous savez ce que vous faites et deux parce que c'st toujours après qu'an ait tapé vingt fois "OUI" qu'on s'aperçoit que finalement fallait pas l'effacer. En fait, j'en mettrai une plus tard, et maintenant vous devriez y arriver tout seul   .

Bonsoir tout le monde,
 
  Je suis un peu grognon car je vois que nous avons pas mal de lecteurs, mais aucun retour. Ainsi, je n'arrive pas à savoir ce que vous désirez réellement. Ce topic est-il trop simple, le code trop pourri (le mien j'entends), vous sert-il quand même,...?
 
 J'ai déjà tué le chien, je peux recommencer avec la belle-mère (ne me tentez pas... Juste un peu). Allez, c'est fini, je sais pas être grognon   .
 
 Bon, on continue. Pour l'instant , je n'ai pas eu encore le temps de tout mettre dans le programme principal, mais fidèle à mon habitude, je vous donne ce que je vais faire et on l'implémente après.
 
 Il était question, tout au début, de courriel. Pour vous faire attendre, voici donc un petit bout de code qui vous permettra d'en envoyer un. Comme sus-mentionné, cela sera implémenté dans le prog principal, dès que j'ai le temps. On se sert du protocole(?) smtp par le biais de la librairie ad-hoc "smtp.ss". Ce petit bout de code est pompé sans remords ici : http://www.htus.org/Book/Staging/how-to-use-modules/
 

 
  Le message doit être une liste de symboles. En fait, chaque retour de ligne doit être un item de liste, justement car il ne prend pas en compte les retour chariot. Donc ici, list-length=3. On s'en occupera lors du passage au graphique.
  A noter qu'il est possible avec drscheme de passer par le protocole mailto. Cependant, je crois ce bout de code est préférable.
 
  Allez, à bientôt.
 
Ps: Si vous n'osez pas "polluer" le topic, rien ne vous empêche d'écrire qqchose et une fois certain que nous l'avons lu, de l'effacer.
 
PS2: En regardant de plus près la fonction "effacer", je m'aperçoit que nous avons construit une fonction "modifier". Ouaip! Affichez une fiche, supprimez -la, modifiez-la et enregistrez-la. C'est fait    Alors là, c'est du pur bourrin  

 Bonsoir à tous,
 
  Non, le projet n'est pas mort, moi non plus. J'avance petit à petit. Déjà qqes modifs on été faites, comme demander l'autorisation d'écrire sur le disque lors de la première utilisation, une chtiote fenêtre qui demandera l'adresse courriel du propriétaire et qq petites choses. Normalement le prog qui enverra le courriel devrait être mis sous forme de module, dès que j'ai pigé qqchose. Et je pense qu'alors, ma mission aura été menée à bien.
 
  Cependant, j'aurai une petite question: j'ai updaté ma version pour la 299.100 afin de pouvoir bénéficier de l'opengl (en fait Glut, je suis sous gnu/linux). Mais rien ne fonctionne, à l'affichage de l'exemple gears.ss, je n'ai que des bouts d'images qui n'ont rien à faire là. Quelqu'un pour m'aider ou pour faire un tuto mzscheme /opengl ?
  Pour vous motiver: http://nothing94.jgb.ca/others/cannonier/ Et ouais, c'est possible en scheme. Et je pense que beaucoup d'autres choses son faisables via SWIG, Guile,... N'hésitez pas à écrire afin d'éclairer le plus de monde. Ce serait sympa un jeu ou un petit éducatif.
 
 Sur ce, à bientôt, c'est presque fini.

Salut, pour ton probleme de opengl ca doit surement venir de tes drivers de carte video (ou ta un beug avec la X Windows Sytem) je pense, car logiquement la librairie de glut de DrScheme est complement autonome (pas besoin de .dll ou de .so) Ou alors t'éxecute du code non compatible avec  la version 299.
 
Sinon pour l'exemple du canonier ... c'est sympa, on peut meme faire des doom-like si ca nous chante.

D'ailleurs pour ne pas aller loin voici la simulation d'un élastique dont je t'avait parlé. Dans le principe ca suit la version C++ dispo sur http://nehe.gamedev.net mais sachant que la couche objet en Scheme est d'une lenteur cosmique j'ai utilisé des structs ce qui permet de gagner minimum 10 fps ...
 
Fichier "algo-mi2.scm"
-----------------------------------------------------------
;;; ALGO-MI2.SCM  
;;; Utilitaires  
;;; [pour DrScheme v203, "Assez gros Scheme"]
 
;;; les boucles classiques WHILE et FOR
 
(define-syntax while
  (syntax-rules ()
    ((while test e1 e2 ...) (do () ((not test) (void)) e1 e2 ...))))
 
(define-syntax for
  (syntax-rules (from to by)
    ((for i from a to b by c e1 e2 ...) (let ([vb b] [vc c])
                                          (do ((i a (+ i vc)))
                                            ((>= i vb) (void))
                                            e1 e2 ...)))
    ((for i from a to b e1 e2 ...) (for i from a to b by 1 e1 e2 ...))
    ((for i from b downto a by c e1 e2 ...) (let ([va a] [vc c])
                                              (do ([i b (- i vc)])
                                                ((< i va) (void))
                                                e1 e2 ...)))
    ((for i from b downto a e1 e2 ...) (for i from b downto a by 1 e1 e2 ...))))
 
 
 
;;; (vector-swap! v i j) echange v[i] et v[j].  
;;; Effet de bord sur v. Retourne v.
 
(define-syntax vector-swap!
  (syntax-rules ()
    ((vector-swap! v i j) (let ([temp (vector-ref v i)])
                            (vector-set! v i (vector-ref v j))
                            (vector-set! v j temp)))))
 
 
 
;;; (vector-quicksort! v [<?]) : un QuickSort sur place, non stable,  
;;; Produit d'un pillage honteux dans plt/collects/mzlib/list.ss
;;; Effet de bord sur v. Retourne v.
;;; [Non verifie, on fait confiance a DrScheme...]
 
(define (vector-quicksort! v . opt)    
  (let ([count (vector-length v)]  
        [<? (if (null? opt) < (car opt))])   ; relation d'ordre STRICT optionnelle
    (define (iter min max)
      (if (< min (sub1 max))
          (let ([pval (vector-ref v min)])
            (define (pivot-loop pivot pos)
              (if (< pos max)
                  (let ([cval (vector-ref v pos)])
                    (if (<? cval pval)
                        (begin
                          (vector-set! v pos (vector-ref v pivot))
                          (vector-set! v pivot cval)
                          (pivot-loop (add1 pivot) (add1 pos)))
                        (pivot-loop pivot (add1 pos))))
                  (if (= min pivot)
                      (iter (add1 pivot) max)
                      (begin
                        (iter min pivot)
                        (iter pivot max)))))
            (pivot-loop min (add1 min)))))
    (iter 0 count)))
 
 
 
(define (vector-bin-search x i j vec . opt)    ; on cherche dans [i,j]
  (let ([<? (if (null? opt) < (car opt))])     ; relation d'ordre strict optionnelle
    (define  (iter i j)
      (if (< j i)
          #f
          (let* ([m (quotient (+ i j) 2)] [xm (vector-ref vec m)])
            (cond [(<? x xm) (iter i (- m 1))]
                  [(<? xm x) (iter (+ m 1) j)]
                  [else m]))))
    (iter i j)))
-----------------------------------------------------------
 
 
Fichier "test.scm"
------------------------------------------------------------  
(load "algo-mi2.scm" )
 
;;;CONSTRUCTOR
(define-struct vector3d (x y z))
 
(define-syntax vec-op
  (syntax-rules ()
    ((vec-op op1 (op2 v ...))
     (op1 (op2 (vector3d-x v) ...)
          (op2 (vector3d-y v) ...)
          (op2 (vector3d-z v) ...)))))
 
;;;MUTATORS;;;;;;;;;;;;;;
 
(define-syntax vec-set
  (syntax-rules ()
    [(_ v1 (op v2 ...))
     (begin
       (set-vector3d-x! v1 (op (vector3d-x v2) ...))
       (set-vector3d-y! v1 (op (vector3d-y v2) ...))
       (set-vector3d-z! v1 (op (vector3d-z v2) ...)))]))
 
(define (vec= v1 v2)
  (vec-set v1 [(lambda (x) x) v2]))  
 
(define (vec-null v)
  (vec-set v [(lambda () 0)]))
 
 
(define (operator= v1 v2)
  (begin
    (set-vector3d-x! v1 (vector3d-x v2))
    (set-vector3d-y! v1 (vector3d-y v2))
    (set-vector3d-z! v1 (vector3d-z v2))
    v1))
 
(define (set-null v)
  (operator= v (make-vector3d 0 0 0)))
 
;;;TO SEE;;;;;;;;;;;;;;;;
(define (show-vec v)
  (vec-op list ((lambda (x) x) v)))
 
;;;ADD;;;;;;;;;;;;;;;;;;;
(define (operator+ v1 v2)
  (vec-op make-vector3d (+ v1 v2)))
 
(define (operator+= v1 v2)
  (operator= v1 (operator+ v1 v2)))
 
;;;SUB;;;;;;;;;;;;;;;;;;;
(define (operator- v1 v2)
  (vec-op make-vector3d (- v1 v2)))
 
(define (operator-= v1 v2)
  (operator= v1 (operator- v1 v2)))
 
;;;NEGATIVE;;;;;;;;;;;;;;
(define (negative v)
  (vec-op make-vector3d (- v)))
 
;;;MULT-BY-SCALAR;;;;;;;;
(define (operator* v k)
  (vec-op make-vector3d ((lambda (x) (* x k)) v)))
 
;;;DIV-BY-SCALAR;;;;;;;;;
(define (operator/ v k)
  (vec-op make-vector3d ((lambda (x) (/ x k)) v)))
 
;;;SCALAR-PROD;;;;;;;;;;;
(define (scalar-product v1 v2)
  (vec-op + (* v1 v2)))
 
;;;LENGTH;;;;;;;;;;;;;;;;
 
(define (length v)
  (sqrt (scalar-product v v)))
 
(define v1 (make-vector3d 1 1 1))
(define v2 (make-vector3d 5 5 5));
 
(show-vec (operator* v1 2))
 
;(show-vec (operator/ v1 2))
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;MASS STRUCTURE
 
(define-struct mass (m pos vel force))
 
(define (apply-force m f)
  (operator+= (mass-force m) f))
 
(define (init m)
  (void (set-null (mass-force m))))
 
(define (simul mass dt) ; méthode d'Euler
  (begin
    (operator+= (mass-vel mass) (operator* (operator/ (mass-force mass) (mass-m mass)) dt))
    (operator+= (mass-pos mass) (operator* (mass-vel mass) dt))))
 
 
;(define a (make-mass 1 (make-vector3d 1 1 1)
;                       (make-vector3d 2 2 2)
;                       (make-vector3d 5 5 5)))
 
;(simulate a 0.002)
 
;(show-vec (mass-pos a))
;(show-vec (mass-vel a))
;(show-vec (mass-force a))
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;SIMULATION STRUCTURE
 
;(define my-sim (make-simulation 0 0 null)) crée une structure sim appele make-masses
 
(define-struct simulation (num m masses))
 
(define (make-masses sim num)
  (set-simulation-num! sim num)
  (set-simulation-masses! sim
   (build-vector num
                 (lambda (x) (make-mass (simulation-m sim)
                                        (make-vector3d 0 0 0)
                                        (make-vector3d 0 0 0)
                                        (make-vector3d 0 0 0))))))
 
 
 
;(define my-sim (make-simulation 4 1 null))
;(make-masses my-sim 4)
 
;my-sim
 
;(simul my-sim 0.002)
 
;(show-vec (mass-pos (vector-ref (simulation-masses my-sim) 0)))
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;ROPE-SIMULATION STRUCTURE
 
(define-struct  
 rope (
       number    ; 1. !!entier!! representant le nombre de masses
       m          ; 2. !!Reel!!   representant le poids de chaque masse
       spring-constant  ; 3. !!Reel!!   representant la rigidit? des ressort (constante)  
       spring-length  ; 4. !!Reel!!   representant la longueur repos du ressort (n'exerce aucune force)
       spring-friction-constant ; 5. !!Reel!! representant la friction (frottements) du ressort (constante)
       gravitation      ; 6 !!vector3d!! representant l'acceleration gravitationelle
       air-friction-constant ; 7. !!Reel!! representant la constante de frottement avec l'air (constante)
       gr-repulsion-constant ; 8. !!Reel!! representant la constante de repulsion du sol (constante)
       gr-friction-constant   ; 9. !!Reel!! representant la constante de frottement avec le sol (constante)
       gr-absorption-constant ; 10. !!Reel!! representant la constante d'absorption du sol (constante)    
       gr-height         ; 11 !!Real!!
       r-con-pos   ; 12 !!vector3d!!
       r-con-vel   ; 13 !!vector3d!!
       masses         ; 14 !!vector!!  
       ))
 
 (define (build-rope r-sim) ; make-rope-simulation doit étre applé avnt cette fonction
   (set-rope-masses! r-sim ; remplissage du vecteur de masses
                             (build-vector (rope-number r-sim)
                                           (lambda (x)  
                                             (make-mass  
                                              (rope-m r-sim) ; m field !!Real!!
                                              (make-vector3d  ;         pos field !!vector3d!!          
                                               (* x (rope-spring-length r-sim)) 0 0) ; setting x-pos    
                                              (make-vector3d 0 0 0) ;   vel field !!vector3d!!
                                              (make-vector3d 0 0 0) ; force field !!vector3d!!
                                               )))))
 
;(show-vec (mass-pos (vector-ref (rope-masses s) 3)))
 
(define (solve r-sim)
  (let ([x 1])  
    (for x from 0 to (- (rope-number r-sim) 1)
         (let* ((o (vector-ref (rope-masses r-sim) x))  
                (o-pos (mass-pos o))
                (o-vel (mass-vel o))
                (force 0)
                (mass1 (vector-ref (rope-masses r-sim) x))
                (mass2 (vector-ref (rope-masses r-sim) (+ x 1)))
                (spring-vector (operator- (mass-pos mass1) (mass-pos mass2))); vecteur entre 2 masses
                (r (length spring-vector)) ; distance entre 2 masses
                (f  (make-vector3d 0 0 0)))
           
               ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
               ;Springs solving
               (if (not (= r 0)) ; pour eviter la division par zero
                     
                   (let ((a (operator/ spring-vector r)); on divise spring-vector par r
                         (b (- r (rope-spring-length r-sim))) ;  r - la longueur repos  
                         (c (- (rope-spring-constant r-sim)))); - la constante de rigidit?
                         
                     (operator+= f (operator* (operator* a b) c))))  
               
               (let ((a (negative (operator- (mass-vel mass1) (mass-vel mass2)))))
                 (operator+= f  
                       (operator* a (rope-spring-friction-constant r-sim)))
                   
                 (apply-force mass1 f)
                 (apply-force mass2 (negative f)))
               
               ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
               ;Applying grav force
               (apply-force o  
                     (operator* (rope-gravitation r-sim) (rope-m r-sim)))
               ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
               ;Applying air-friction
               (operator+= (mass-force o)
                           (operator* ;  
                            (negative  
                             (mass-vel o)) ; velocit? de la masse (=>vector3d)  
                            ; sa negation (=>vector3d)
                            ; qu'on multiplie par
                            (rope-air-friction-constant r-sim)))
 
 
   
           ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
           ;Applying the ground repulsion
           
           (if (< (vector3d-y o-pos) (rope-gr-height r-sim))
               ; !!! LA FORCE DU SOL AGIT SUR LA MASSE SSI ELLE ENTRE EN COLLISION AVEC LE SOL !!!
               (let ((v o-vel))
                 (set-vector3d-y! v 0)
                 
                 (operator+= (mass-force mass1) ; application de la force de frottement du sol f=f+(-v*cst)
                             (operator* (negative v) (rope-gr-friction-constant r-sim)))
                 
                 
                 (set! v (make-vector3d 0 (vector3d-y o-vel) 0))  
                 
                 ; Ainsi on a obtenu une velocité qui est perpendiculaire au sol et qui est necessaire
                 ; pour la force d'absorption.  
                 
                 (if (< (vector3d-y v) 0)  
                     ; on absorbe l'energie cinetique si la masse est en collision avec le sol
                     (operator+= mass1 (operator* (negative v) (rope-gr-absorption-constant r-sim))))
               
                 (apply-force mass1 (operator* (make-vector3d 0 (rope-gr-repulsion-constant r-sim) 0)  
                                             (- (rope-gr-height r-sim) (vector3d-y o-pos)))))
           )))))
   
(define s (make-rope
             12 ; 1. 80 particules (num-of-masses)
             0.05 ; 2. Chaque particules a un poids de 50 grames
             10000.0 ; 3. Constante de rigidit? du ressort (spring-constant)
             0.05 ; 4. Longueur repos du ressort (spring-length)  
             0.2 ; 5. Constante de friction (frottement) du ressort (spring-friction-constant)
             (make-vector3d 0 -9.81 0) ; 6. Acceleration gravitationelle terrestre (gravitation)
             0.02 ; 7. Constante de frottement avec l'air (air-friction-constant)
             100.0 ; 8. Constante de repulsion du sol (ground-repulsion-constant)
             0.2 ; 9. Constante de frottement avec le sol (ground-friction-constant)
             2.0 ; 10. Constante d'absorption d'energie du (ground-absorption-constant)
             -1.5 ; 11. Hauteur du sol
             (make-vector3d 0 0 0) ; 12.
             (make-vector3d 0 0 0) ; 13.
             null ; 14.
             ))  
 
(build-rope s)  
 
(solve s)
 
;(show-vec (mass-pos (vector-ref (rope-masses s) 3)))
                     
                     
(define (simulate r-sim dt)
  (begin
    (let ([x 1])
      (for x from 0 to (rope-number r-sim)  
           (simul (vector-ref (rope-masses r-sim) x) dt)))
    (operator+= (rope-r-con-pos r-sim) (operator* (rope-r-con-vel r-sim) dt))
    (let ((h (rope-gr-height r-sim))
          (o (vector-ref (rope-masses r-sim) 0))
          (pos (rope-r-con-pos r-sim))
          (vel (rope-r-con-vel r-sim)))
                 
      (if (< (vector3d-y (rope-r-con-pos r-sim)) h) ;rope-connection ne doit descendre plus bas que le sol
          (begin
            (set-vector3d-y! pos h)
            (set-vector3d-y! vel 0.05)))
       
      (operator= (mass-pos o) pos)
      (operator= (mass-vel o) vel))))
 
(define (operate r-sim dt)
  (void
   (begin
     (let ([x 1])
       (for x from 0 to (rope-number r-sim)  
            (init (vector-ref (rope-masses r-sim) x))))
     (solve r-sim)
     (simulate r-sim dt)
     (set-null (rope-r-con-vel r-sim)))))
 
 
(build-rope s)  
 
(operate s 0.02)
 
(show-vec (mass-pos (vector-ref (rope-masses s) 0)))
-----------------------------------------------------------
 
Fichier "alpha.scm" - le fichier principal
-----------------------------------------------------------
 
 
 
(require (lib "mred.ss" "mred" )
         (lib "class.ss" )
         (lib "math.ss" )
         (prefix gl- (lib "sgl.ss" "sgl" ))
         (lib "gl-vectors.ss" "sgl" )
         (lib "gl.ss" "sgl" ))
(load "test.scm" )
(load "algo-mi2.scm" )
 
(define cube-canvas%
   
  (class* canvas% ()  
     
    (inherit refresh with-gl-context swap-gl-buffers)  
     
    (define start #t)
     
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;
     
    (define rope-simul (make-rope  
                         20 ; 1. 80 particules (num-of-masses)
                         0.05 ; 2. Chaque particules a un poids de 50 grames
                         10000.0 ; 3. Constante de rigidit? du ressort (spring-constant)
                         0.05 ; 4. Longueur repos du ressort (spring-length)  
                         2 ; 5. Constante de friction (frottement) du ressort (spring-friction-constant)
                         (make-vector3d 0 -9.81 0) ; 6. Acceleration gravitationelle terrestre (gravitation)
                         0.02 ; 7. Constante de frottement avec l'air (air-friction-constant)
                         100.0 ; 8. Constante de repulsion du sol (ground-repulsion-constant)
                         0.2 ; 9. Constante de frottement avec le sol (ground-friction-constant)
                         0.0 ; 10. Constante d'absorption d'energie du (ground-absorption-constant)
                         -1.5 ; 11. Hauteur du sol
                         (make-vector3d 0 0 0) ; 12.
                         (make-vector3d 0 0 0) ; 13.
                         null)) ; 14.
    (build-rope rope-simul)
     
     
    (define dt (current-seconds)) ; on choppe le temps
    (define max-dt 0.002) ; le dt maximum (necessaire pour eviter les decalages, ou sacades)  
    (define num-of-iterations ; Calcule le nombre d'iterations a faire a ce moment donn?
      (+ (round (/ dt max-dt)) 1))
     
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;;Variables pour l'eclairage
     
    (define light #t) ; Eclairage ON / OFF
    (define blend #t) ; Transparence ON / OFF
     
    (define/override (on-size width height) ; <=> Resize on "redefini" le on-size de la classe canvas% d'ou le override
       
      (with-gl-context  
                   
       (lambda ()
       
         (gl-viewport 0 0 width height) ; creation d'un viewport d'opengl                      
         (gl-matrix-mode 'projection)   ; matrice projective                      
         (gl-load-identity)             ; centre du viewport                      
         (let ((h (/ height width))) ; pas de glu ...  
           (gl-frustum -1.0 1 (- h) h 6.0 60.0))
         (gl-matrix-mode 'modelview)
         (gl-load-identity)              
         (gl-translate 0.0 0.0 -10.0) ; zoom principal de la scene
               
         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
         ;Les enables et autres :
         
         ;(gl-enable 'cull-face) ; calculer uniquement les faces visibles
         (glClearDepth 1)
         
         (gl-enable 'depth-test) ; test du z-buffer (profondeur)
         (glDepthFunc GL_LEQUAL)
         (glHint GL_PERSPECTIVE_CORRECTION_HINT GL_NICEST) ; optimisation de la perspective
         ;(send
         ; (send
         ;  (send rope-simul get-mass (- (send rope-simul get-num-of-masses*) 1))
         ;  get-vel)
         ; set-z 3.0) ;Chaque fois qu'on redimensione la fenetre le bout de la corde se positionne a cette hauteur          
         
         (gl-enable 'normalize)
         ))
      (refresh))  
     
     
    (define/override (on-paint) ; <=> DrawGLScene, on "redefini" le on-paint de la classe canvas% d'ou le override
       (when start
           (begin
             
             (set! num-of-iterations (+ (round (/ (- (current-seconds) dt) max-dt)) 1))
             (if (not (= num-of-iterations 0)) ; avoid the division by zero
                 (set! dt (/ dt num-of-iterations)))  ; dt doit etre mis a jour selon le nombre d'iterations
             
             (let ([x 1])
               (for x from 0 to num-of-iterations  ; calculate it num-of.. times
                    (operate rope-simul (if (> dt max-dt)  
                                            0.002
                                            dt))))))
                                             
      (with-gl-context ;  
       (lambda () ;  
         
         (glClearColor 0.0 0.0 0.0 0.5)                   ; on definit la couleur du fond    
         (gl-clear 'color-buffer-bit 'depth-buffer-bit)   ; on vide les buffers de couleur et de profondeur
         
         (glBegin GL_QUADS);
         (let ((h (rope-gr-height rope-simul)))
           (glColor3ub 0 0 255); Couleur bleu clair
           (glVertex3f 5 h 5);
           (glVertex3f -20 h 20);
           (glColor3ub 50 50 70); Couleur noire
           (glVertex3f -20 h -20);
           (glVertex3f 20 h -20));
         (glEnd);
         
         
         
         ;The shadow of the rope
         (glColor3ub 0 0 0); Couleur noire
         
         (let ([x 1])
           (for x from 0 to (- (rope-number rope-simul) 2)  
                (let* ((mass1 (vector-ref (rope-masses rope-simul) x))
                      (pos1  (mass-pos mass1))
                      (mass2 (vector-ref (rope-masses rope-simul) (+ x 1)))
                      (pos2  (mass-pos mass2)))
                  (glLineWidth 2);
                  (glBegin GL_LINES);
                  (glVertex3f (vector3d-x pos1) ; Dessine l'ombre sur le sol (premier bout)  
                              (rope-gr-height rope-simul)
                              (vector3d-z pos1))
                  (glVertex3f (vector3d-x pos2) ; Dessine l'ombre sur le sol (deuxieme bout) et ainsi de suite ...
                              (rope-gr-height rope-simul)
                              (vector3d-z pos2))
                  (glEnd)
                  )))
         
         
         ;Draw the rope
         (glColor3ub 255 255 0); Couleur jaune (yellow color)
         (gl-push-matrix)
         (glLineWidth 3)
         (let ([x 1])
           (for x from 0 to (- (rope-number rope-simul) 2)  
                (let* ((mass1 (vector-ref (rope-masses rope-simul) x))  
                       (pos1  (mass-pos mass1))
                       (mass2 (vector-ref (rope-masses rope-simul) (+ x 1)))
                       (pos2  (mass-pos mass2)))
                   
                   
                  (glBegin GL_LINES)
                  (glVertex3f (vector3d-x pos1)
                              (vector3d-y pos1)
                              (vector3d-z pos1))  
                  (glVertex3f (vector3d-x pos2)
                              (vector3d-y pos2)
                              (vector3d-z pos2))
                  (glEnd)
                  )))
         (gl-pop-matrix)
         
         
         
                             
         (swap-gl-buffers)
         (glFlush)                                      
         
           ))
      (set! dt (current-seconds))    
      (refresh))
         
         
         (define/override (on-char key)
           (let ((k (send key get-key-code))
                 (temp (rope-r-con-vel rope-simul)))
 
             (cond ((eq? k 'escape) (exit))
 
                   ((eq? k 'down)  ; si BAS appuyee
                    (operator= temp (make-vector3d 0.0 0.0 30.0)))
                       
                   ((eq? k 'up)    ; si HAUT appuyee
                    (operator-= temp (make-vector3d 0.0 0.0 30.0)))
                       
                   ((eq? k 'right) ; si DROITE appuyee
                    (operator+= temp (make-vector3d 30.0 0.0 0.0)))
                   
                   ((eq? k 'left) ; si GAUCHE appuyee
                    (operator-= temp (make-vector3d 30.0 0.0 0.0)))
                       
                   ((eq? k 'home) ; si HOME
                    (operator+= temp (make-vector3d 0.0 30.0 0.0)))
                       
                   ((eq? k 'end)  ; si END
                    (operator-= temp (make-vector3d 0.0 30.0 0.0)))
                   ((eq? k '#\1) ; si 1 appuye? (Montrer cube)
                    (if show-pyramid
                        (set! show-cube #f)
                        (set! show-cube #t)))
                       
                   ((eq? k 'f1)  
                    (let ((x (send frame get-width))
                          (y (send frame get-height)))
                      (send frame maximize #t)
                      (if (and (= (send frame get-width) x)
                               (= (send frame get-height) y))
                          (send frame maximize #f)))))))
         
         
         
         
    (super-instantiate () (style '(gl no-autoclear)) )))  
 
         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;Gestion des fenetres
 
(define frame (make-object frame% "Rope-Simulation" #f))
 
 
(define (Main)
  (let* ((c (instantiate cube-canvas% (frame) (min-width 300) (min-height 300))))
    (send frame create-status-line)
     
    (instantiate horizontal-panel% (frame)
      (alignment '(center center)) (stretchable-height #f))
    (send frame show #t)))
(Main)
-----------------------------------------------------------
 
Les movements ne sont pas aussi fluides et réalistes que dans la version de nehe mais bon ca donne plus un élastique avec l'attraction lunaire qu'une corde (je dois avoir quelques houilles avec les constantes)  
 
J'ai testé sur la 299 ça marche au top chez moi sachant qu'au départ c'était écris avec la 260 je crois ...  
 

 
Un truc marrant ça serait de mettre une boule (avec des piques ? ) au bout de la corde.

Salut,    
 
  Finis les exams. Les résultats, c'est quand?
  Merci pour ton prog, je me penche dessus demain. Mes écoles vont bientôt fermer, j'aurai enfn un peu de temps. Je ferai un peu de ménage dans ce post et finirai notre annuaire. Je cale un peu sur la fonction qui me fera une liste des lignes pour envoyer le mail, et après,... on verra.
 
 Je vais me pencher sur mes drivers, mais glgears fonctionne bien, ça cavale même. Je m'étendrai un peu plus demain, c'est sympa d'être passé, ça fait plaisir. On attaque un jeu après   ?
  Bonne nuit.

Shalu ! Bein j'ai eut les résultats je passe nikel sans ratrapage ... j'ai meme pas eut l'ocase de faire peter le champs    
 
Sinon pour aprés je pensais à un truc ... on pourrait eventuellement se taper un ptit délire sur un jeu d'échecs ? genre sans rentrer dans les systemes experts mais essayer de faire marcher un peu les neurones du pc en faisant un joueur virtuel.
 
Sinon un ptit jeu d'arcade genre baston ou shoot (pas rpg plz )  
 
T'en pense quoi ?

Ben félicitations !
 
  Comme prévisible #@!§# l'affichage déconne. Je vais revoir mes drivers ou mes bibliothèques, ou les deux.
 
   Partant pour tout. Mais un jeu pour commencer pourrait satisfaire une plus grande demande de la part de nos lecteurs. J'ai l'impression que le côté graphique de scheme les intéresse beaucoup. Si l'on peut faire des anims fluides avec le canvas% de drscheme sans avoir à acheter un CRAY II, ce serait bien. Et après le jeux d'échec. Ce qui nous permettrait aussi, peut-être, d'y coupler un graphisme "original". (euh le rpg,c'est le truc genre Donjon & Dragon   ? Si oui t'inquiètes pas). Un shoot me parait bien (sinon t'appelles quoi baston, genre Street-fighter?)
   Encore une fois, si tu veux de l'aide n'oublie pas mon niveau, il va falloir m'expliquer looooonnnnnguement certains points.
   Bon, je tente de finir cette pu**** de liste, qq fignolages et c'est reparti. (Bordel de text-snip%).
 
   Et puis le champ, c'est surfait: une triple Karmelitte assez fraîche dans un verre tulipe, excellent.

Salut à tous !
 
 La mouture finale du Super_Annuaire est enfin disponible. Vous la trouverez là où était la précédente version, c'est à dire un peu plus haut. Vous pourrez même envoyer des courriels. Si,si.
 
  Avec Chonoklazm, on commence à vous proposer des petits "tutos". Allez voir en première page, un petit sur les doublets.
 
  Ne vous effrayez pas pour le bazar, on va le résorber au fur et à mesure. Et encore une fois, n'hésitez pas à poser des questions ou à faire un commentaire.
 
Edit: J'avais omis de vous dire de manière explicite comment nommer les fichiers. Chose faite. Oups!

Yo, j'ai testé le ptit pacman animé sur le site schemecookbook c'est sympa sauf qu'on peut même pas fermer la fenetre sans tuer le processus principal donc voila je propose une petite manip qui enleve ce beug.
 
Le probleme vient de :
 
(define (control-loop)
  (let loop ([t (* -9 pi)])
    (update-view t)
    (sleep PAUSE)
    (loop (+ t .002))))
 
Ici il nous faut simplement arreter la boucle (que l'on peut forcer a être un processus légér) pas le processus general et sachant que l'instruction sleep "endors" le processus courant on peut resoudre ceci grace à :
 
(define (control-loop)
  (thread (lambda ()
  (let loop ([t (* -9 pi)])
    (update-view t)
    (sleep/yield PAUSE)
    (loop (+ t .002))))))

Continuez les gars, vous faites un super topic !

Y'en a un    Merci el muchacho, c'est super sympa.
 
 Donc, comme amorcé avec le post de Chronoklazm, nous entrons dans les animations. Le pacman dont il parle se trouve ici : http://schemecookbook.org/Cookbook/GUIRecipeAnimation Je vous conseille aussi ces pages-ci:
 http://www.cs.wpi.edu/~kfisler/Cou [...] /lab4.html http://www.htdp.org/2001-11-21/Book/node32.htm . Bon, si vous êtes comme moi, cela ne va pas forcément vous éclairer. Donc, je vais tenter de reprendre les bases et on tâchera de complexifier au fur et à mesure.
 
  Pour produire une animation, nous avons besoin de deux types de données : Une image et le trajet que devra accomplir l'image. Nous allons commencer avec un rectangle que nous afficherons, effacerons,... le long d'une trajectoire. Il y a certainement d'autres methodes d'affichage, comme la bufférisation, mais pour l'instant, on va faire simple. D'ailleurs, comme pour l'annuaire, j'apprends en même temps que vous, soyez donc cléments. Je pense que Chronoklazm prendra le relais, et là faudra vous accrocher.
 
  Tout d'abord, vous aurez besoin de la librairie "draw.ss". Deux solutions, soit la charger comme vous avez l'habitude (require(lib.....)) ou en l'ajoutant dans les teachpack, au choix. Commençons:

On ouvre un canvas de taille x y

On définit les variable qui sont les coordonnées de départ et le temps que restera affichée l'image avant de l'effacer. Cela va  conditionner la rapidité de l'anim.

C'est une fonction simple qui s'arrête quand x vaudra 300. Elle affiche le rectangle, pause, efface, incrémente x et affiche. La dernière ligne est pour appeler la fonction car je programme comme un porc et j'ai voulu faire du compact.
 
  Maintenant, jouez sur la valeur de sleep, essayez sans l'effacement (clear-solid...),tentez d'autres trajectoires et amusez-vous. Pourquoi une telle différence d'avec le pacman sus-cité? La réponse au prochain numéro.
Bonne nuit.

Cool !    
 
J'ai remarqué que lorsqu'on arrete l'execution de (anim vect-dx) la fenetre des interactions est bloqué (meme probleme du sleep/yield que pour le pacman) ... donc un petit rafistolage s'impose :
 
(require (lib "draw.ss" "htDP" ))
 
(define vect-dx 50)
(define vect-dy 70)
(define sleep 0.03)
(define (anim vect-dx)
  (thread (lambda()
            (if(= vect-dx 300)
               (stop)
               (begin
                 (clear-all)  
                 (draw-solid-rect(make-posn vect-dx vect-dy) 50 70 'blue)
                 (sleep/yield sleep)            
                 (anim (+ vect-dx 1)))))))
(start 300 200)
(anim vect-dx)
 
Sinon y quelques sacades lors du déplacement ... à mon avis ca vient du temps de pause.