Bug sur un vieux lisp

[Francis]

Bonjour à tous!

Premier Post sur ce forum que je suis depuis quelque temps déjà.

En ces temps de confinement (j'espère que vous vous portez bien), je me retrouve sans Covadis ni aucun autre applicatif...

Dans le cadre d'un projet (scolaire!) je vais devoir réaliser une division de parcelle en vue d'un projet de lotissement, j'ai donc ressorti des vieux LISPS que j'avais retouché (et tenté de traduire) en cabinet pour des vieilles versions d'AutoCAD. Or, depuis que ma licence "Étudiant" m'a contraint au passage sur 2020, celui-ci ne fonctionne plus.

Message me demandant de sélectionner un calque sans pouvoir en sélectionner un, j'avoue ne pas comprendre d'où ça vient.

 

Ce lisp fonctionne de la manière suivante:

 

on sélectionne une polyligne de contour (fermée)

on précise si on veut diviser en un nombre de lots ou decouper une surface seulement

 

Si découpage en lots, on précise le nombre de lots

Si découpage d'une surface, on précise combien en m²

 

On choisit comment tracer la limite:

parallèle à un coté ou en sélectionnant 2 points de passage dits "fixes"

 

 

En fonction, on sélectionne

 

Ensuite le LISP trace et adapte de manière a conserver ce qui est demandé

 

Le LISP en question:

 

;;;DIVAREA.LSP  Land division utility - Modifié et traduit par Francis
;;;  Supposez que vous devez diviser une parcelle en un certain nombre de lots
;;;  ou que vous vouez seulement retrancher une certaine surface à une parcelle plus grande
;;;
;;;  Vous avez seulement besoin d'une polyligne de contour fermée
;;;
;;;  Repondez aux quelques questions et rappelez-vous:
;;;
;;;  Lorsqu'il vous sera demandé d'indiquer approximativement 2 points de
;;;  la limite, prenez en compte que
;;;
;;;     1. Cette limite va subir une rotation ou être décallée et
;;;  aucun de ses points d'éxtrémité ne doit être en dehors des limites de la parcelle,
;;;  
;;;  Donc choisissez des points le plus loin possible de la limite
;;;  sans exceder, bien entendu, les limites de votre parcelle
;;;  Pour la méthode dite "fixe",
;;;  les points doivent être situé sur la polyligne de contour ou
;;;  à l'exterieur mais jamais à l'intérieur
;;;
;;;     2. Lorsque vous pointerez la parcelle qui aura la surface désirée
;;;  vous devrez pointer dans le contour de la parcelle et le plus loin possible de la limite divisoire
;;;  Ainsi, ce point ne sera pas en dehors de la zone désirée lorsque la limite se déplacera.
;;;  
;;;
;;;     3. Enfin, vous aurez à pointer exactement de la même manière,
;;;  loin de la limite divisoire et dans la parcelle restante. 
;;;
;;;*************************************************




(defun prerr (s)
(if (/= s "Fonction Annulée")
    (princ (strcat "\nErreur: " s))
);endif
(setq *error* olderr)
(princ)
);close defun

(Defun C:DDIVAREA(/ osm strpf strdc ex arxset arx arxon k scl ok
                  d p1 p2 pts ptb deln ar par tem
                  stp stp1 stp2               
               )
(setq olderr *error*
      *error* prerr)
(setq osm(getvar "osmode"))
(setvar "osmode" 0)
(setvar "cmdecho" 0)
(setq ex 0
      stp  0.01
      stp1 0.005
      stp2 0.0005
)
(setq arxset (entsel "\nSelectionnez une Polyligne de contour fermee: ")
      arx    (entget(car arxset))
      arxon  (cdr (assoc -1 arx))
)
(if (not(and(equal (cdr(assoc 0 arx)) "LWPOLYLINE") (= (cdr(assoc 70 arx)) 1)))
    (progn
          (princ "\nCeci n'est pas une polyligne de contour fermee... :-( ")
          (setq ex 1)
    )
)
(if (= ex 0)
    (progn
      (command "_undo" "m") ;if something goes bad, you may return here
      (command "_layer" "m" "div" "")
      (command "_area" "e" arxon)
      (setq ar(getvar "area"))
      (initget "Divide Cut")
      (setq strdc(getkword "\nDIVISER par un nombre ou DECOUPER une surface? (D/C) :"))
      (if (= strdc "Divide")
          (progn
                (setq k  (getreal "\nSpecifiez le nombre de lots à diviser: "))
                (setq tem(/ ar k))
          )
      )
      (if (= strdc "Cut")
          (setq tem (getreal "\nSpécifiez l'aire à decouper depuis la parcelle(m2) : "))
      )
      (initget "Parallel Fixed")
      (setq strpf(getkword "\nPARALLELE a une direction ou FIXE par rapport à un côté? (P/F) :"))
      (if (= strpf "Fixed")
          (fixpt)
      )
      (if (= strpf "Parallel")
          (parpt)
      )
      (ready)
    )
    (ready)
)
)
;******************************************************************************
(defun fixpt ()
(setvar "osmode" osm)
(setq scl    0.05
      p1     (getpoint "\nChoisissez un premier point fixe sur la limite divisoire : ")
      p2     (getpoint "\nChoisissez un second point fixe sur la limite divisoire: ")
)
(setvar "osmode" 0)
(command "_line" p1 p2 "")
(setq deln (entlast))
(setq pts (getpoint "\nChoisissez un point dans le premier lot, eloigné de la limite divisoire: "))
(setq ptb (getpoint "\nChoisissez un point dans le reste de la parcelle, eloigné de la limite divisoire: "))
(setvar "blipmode" 0)
(princ "\nPatientez...")
(command "_boundary" pts "")
(command "_area" "e" "l")
(setq par(getvar "area"))
(setq ok -1)
(if (< par tem)
 (progn
       (while (< par tem)
        (entdel (entlast))
        (if (< (- tem par) 50)(setq scl stp))
        (if (< (- tem par) 10)(setq scl stp2))
        (command "_rotate" deln "" p1 (* scl ok))
        (command "_boundary" pts "")
        (command "_area" "e" "l")
        (if (< (getvar "area") par)
            (setq ok(* ok -1))
        )
        (setq par(getvar "area"))
       );endwhile
       (entdel deln)
)
 (progn
       (while (> par tem)
        (entdel (entlast))
        (if (< (- par tem) 50)(setq scl stp))
        (if (< (- par tem) 10)(setq scl stp2))
        (command "_rotate" deln "" p1 (* scl ok))
        (command "_boundary" pts "")
        (command "_area" "e" "l")
        (if (> (getvar "area") par)
            (setq ok(* ok -1))
        )
        (setq par(getvar "area"))
       );endwhile
       (entdel deln)
)
)
(command "_change" "l" "" "p" "c" "green" "")
(command "_boundary" ptb "")
(command "_change" "l" "" "p" "c" "red" "")
(ready)
)
;******************************************************************************
(defun parpt ()
(setvar "osmode" osm)
(setq scl    0.25
      p1     (getpoint "\nChoisissez un premier point sur la limite divisoire (Eloigné de votre contour) : ")
      p2     (getpoint "\nChoisissez un second point sur la limite divisoire (Eloigné de votre contour)  : ")
)
(setvar "osmode" 0)
(command "_line" p1 p2 "")
(setq deln(entlast))
(setq pts (getpoint "\nChoisissez un point dans le premier lot, eloigné de la limite divisoire: "))
(setq ptb (getpoint "\nChoisissez un point dans le reste de la parcelle, eloigné de la limite divisoire: "))
(setvar "blipmode" 0)
(princ "\nPatientez...")
(command "_boundary" pts "")
(command "_area" "e" "l")
(setq par(getvar "area"))
(if (< par tem)
 (progn
       (while (< par tem)
        (entdel (entlast))
        (if (< (- tem par) 50)(setq scl stp1))
        (if (< (- tem par) 10)(setq scl stp2))
        (command "_offset" scl deln ptb "")
        (entdel deln)
        (setq deln(entlast))
        (command "_boundary" pts "")
        (command "_area" "e" "l")
        (setq par(getvar "area"))
       )
       (entdel deln)
 )
 (progn
       (while (> par tem)
        (entdel (entlast))
        (if (< (- par tem) 50)(setq scl stp1))
        (if (< (- par tem) 10)(setq scl stp2))
        (command "_offset" scl deln pts "")
        (entdel deln)
        (setq deln(entlast))
        (command "_boundary" pts "")
        (command "_area" "e" "l")
        (setq par(getvar "area"))
       )
       (entdel deln)
 )
)
(command "_change" "l" "" "p" "c" "green" "")
(command "_boundary" ptb "")
(command "_change" "l" "" "p" "c" "red" "")
)
;******************************************************************************
(defun ready ()
 (princ scl)
 (princ "\nActuelle : ")
 (princ par)
 (princ "\nDoit être: ")
 (princ tem)
(setq *error* olderr)
(setvar "osmode" osm)
(setvar "cmdecho" 1)
(setvar "blipmode" 1)
(princ "\nFini! :-) ")
(princ)
);close defun

 

Si quelqu'un a un petit peu de temps pour m'aider à résoudre mon problème...

 

Merci d'avance,

 

Francis :)

[Francis]

Je ne l'ai peut-être pas assez précisé, mais ce LISP sert à réaliser des divisions de parcelles! :)

[Fraid]

Bonjour, et bienvenu

 

Reprendre une routine Autolisp que l'on a pas écrit c'est Trés difficile.

 

par contre,

 

Message me demandant de sélectionner un calque sans pouvoir en sélectionner un, j'avoue ne pas comprendre d'où ça vient

 

de plus, c'est une version anglaise

 

(command "_layer" "m" "div" "")

 

l'option m en français n'existe pas ...

 

Tu vas devoir apprendre l'Autolisp pour t'en sortir.

 

Bon courage

[lecrabe]

Hello

 

+1 avec Fraid !

 

DEJA il faut modifier le Lisp "un peu partout" pour lui faire passer des commandes et options US/English

PREFIXE par un "_" (underscore) pour avoir une chance de fonctionner sur un AutoCAD French !

 

LA SANTE, Bye, lecrabe "triste"

Automne 2020, la retraite ...

[Francis]

Mais bien sûr, pourquoi je n'y ai pas pensé avant?!

La version d'AutoCAD que j'avais utilisé avec ce LISP était en Anglais, d'où mon erreur!

Comme quoi il m'en reste encore pas mal à apprendre :(rires forts):

Merci beaucoup pour vos réponses et pour votre rapidité, bonne journée :)

[lecrabe]

Hello

 

SVP quand tu auras TOUT corrige et que ca fonctionne bien !?

tu nous posteras la bonne version pour AutoCAD French ...

 

LA SANTE, Bye, lecrabe "triste"

Automne 2020, la retraite ...

[Francis]

Bonjour bonjour,

 

Réponse quelque peu tardive et je m'en excuse...

 

Voici le Lisp corrigé, même s'il n'est pas d'une rapidité incroyable il a au moins le mérite de fonctionner

 

Quand j'aurais un poil plus de temps, je rajouterai une petite fonction (voir une boîte dcl!) permettant de paramétrer la tolérance lors des calculs de surfaces.

 

Voici le code:

;;;DIVAREA.LSP  Land division utility - Modifié et traduit par Francis
;;;  Supposez que vous devez diviser une parcelle en un certain nombre de lots
;;;  ou que vous vouez seulement retrancher une certaine surface à une parcelle plus grande
;;;
;;;  Vous avez seulement besoin d'une polyligne de contour fermée
;;;
;;;
;;;
;;;  Lorsqu'il vous sera demandé d'indiquer approximativement 2 points de
;;;  la limite, prenez en compte que
;;;
;;;     1. Cette limite va subir une rotation ou être décalée et
;;;  aucun de ses points d’extrémité ne doit être en dehors des limites de la parcelle,
;;;  
;;;  Donc choisissez des points le plus loin possible de la limite
;;;  sans excéder, bien entendu, les limites de votre parcelle
;;;  Pour la méthode dite "du point fixe",
;;;  les points doivent être situé sur la polyligne de contour ou
;;;  à l’extérieur mais jamais à l'intérieur
;;;
;;;     2. Lorsque vous pointerez la parcelle qui aura la surface désirée
;;;  vous devrez pointer dans le contour de la parcelle et le plus loin possible de la limite divisoire
;;;  Ainsi, ce point ne sera pas en dehors de la zone désirée lorsque la limite se déplacera.
;;;  
;;;
;;;     3. Enfin, vous aurez à pointer exactement de la même manière,
;;;  loin de la limite divisoire et dans la parcelle restante. 
;;;
;;;*************************************************




(defun prerr (s)
(if (/= s "Interruption")
    (princ (strcat "\nErreur: " s))
);endif
(setq *error* olderr)
(princ)
);close defun

(Defun C:TRDiv(/ osm strpf strdc ex arxset arx arxon k scl ok
                  d p1 p2 pts ptb deln ar par tem
                  stp stp1 stp2               
               )
(setq olderr *error*
      *error* prerr)
(setq osm(getvar "osmode"))
(setvar "osmode" 0)
(setvar "cmdecho" 0)
(setq ex 0
      stp  0.01
      stp1 0.005
      stp2 0.0005
)
(setq arxset (entsel "\nSelectionner une Polyligne de contour fermee: ")
      arx    (entget(car arxset))
      arxon  (cdr (assoc -1 arx))
)
(if (not(and(equal (cdr(assoc 0 arx)) "LWPOLYLINE") (= (cdr(assoc 70 arx)) 1)))
    (progn
          (princ "\nCeci n'est pas une polyligne de contour fermee...")
          (setq ex 1)
    )
)
(if (= ex 0)
    (progn
      (command "_undo" "_m") ;if something goes bad, you may return here
      (command "_layer" "_m" "Division" "")
      (command "_area" "_e" arxon)
      (setq ar(getvar "area"))
      (initget "Divide Cut")
      (setq strdc(getkword "\nDiviser par un nombre ou deCouper une surface? (D/C) :"))
      (if (= strdc "Divide")
          (progn
                (setq k  (getreal "\nSpecifier le nombre de lots: "))
                (setq tem(/ ar k))
          )
      )
      (if (= strdc "Cut")
          (setq tem (getreal "\nSpecifier l'aire extraite depuis la parcelle (m2) : "))
      )
      (initget "Parallel Fixed")
      (setq strpf(getkword "\nParallele a une direction ou Fixe par rapport a un cote? (P/F) :"))
      (if (= strpf "Fixed")
          (fixpt)
      )
      (if (= strpf "Parallel")
          (parpt)
      )
      (ready)
    )
    (ready)
)
)
;******************************************************************************
(defun fixpt ()
(setvar "osmode" osm)
(setq scl    0.05
      p1     (getpoint "\nChoisir un premier point fixe sur la limite divisoire : ")
      p2     (getpoint "\nChoisir un second point flottant sur la limite divisoire: ")
)
(setvar "osmode" 0)
(command "_line" p1 p2 "")
(setq deln (entlast))
(setq pts (getpoint "\nChoisir un point dans le premier lot, loin de la limite divisoire: "))
(setq ptb (getpoint "\nChoisir un point dans le reste de la parcelle, loin de la limite divisoire: "))
(setvar "blipmode" 0)
(princ "\nPatientez...")
(command "_boundary" pts "")
(command "_area" "_e" "_l")
(setq par(getvar "area"))
(setq ok -1)
(if (< par tem)
 (progn
       (while (< par tem)
        (entdel (entlast))
        (if (< (- tem par) 50)(setq scl stp))
        (if (< (- tem par) 10)(setq scl stp2))
        (command "_rotate" deln "" p1 (* scl ok))
        (command "_boundary" pts "")
        (command "_area" "_e" "_l")
        (if (< (getvar "area") par)
            (setq ok(* ok -1))
        )
        (setq par(getvar "area"))
       );endwhile
       (entdel deln)
)
 (progn
       (while (> par tem)
        (entdel (entlast))
        (if (< (- par tem) 50)(setq scl stp))
        (if (< (- par tem) 10)(setq scl stp2))
        (command "_rotate" deln "" p1 (* scl ok))
        (command "_boundary" pts "")
        (command "_area" "_e" "_l")
        (if (> (getvar "area") par)
            (setq ok(* ok -1))
        )
        (setq par(getvar "area"))
       );endwhile
       (entdel deln)
)
)
(command "_change" "_l" "" "_p" "_c" "_green" "")
(command "_boundary" ptb "")
(command "_change" "_l" "" "_p" "_c" "_red" "")
(ready)
)
;******************************************************************************
(defun parpt ()
(setvar "osmode" osm)
(setq scl    0.25
      p1     (getpoint "\nChoisir un premier point sur la limite divisoire (loin de votre contour) : ")
      p2     (getpoint "\nChoisir un second point sur la limite divisoire (loin de votre contour)  : ")
)
(setvar "osmode" 0)
(command "_line" p1 p2 "")
(setq deln(entlast))
(setq pts (getpoint "\nChoisir un point dans le premier lot, loin de la limite divisoire: "))
(setq ptb (getpoint "\nChoisir un point dans le reste de la parcelle, loin de la limite divisoire: "))
(setvar "blipmode" 0)
(princ "\nPatientez...")
(command "_boundary" pts "")
(command "_area" "_e" "_l")
(setq par(getvar "area"))
(if (< par tem)
 (progn
       (while (< par tem)
        (entdel (entlast))
        (if (< (- tem par) 50)(setq scl stp1))
        (if (< (- tem par) 10)(setq scl stp2))
        (command "_offset" scl deln ptb "")
        (entdel deln)
        (setq deln(entlast))
        (command "_boundary" pts "")
        (command "_area" "_e" "_l")
        (setq par(getvar "area"))
       )
       (entdel deln)
 )
 (progn
       (while (> par tem)
        (entdel (entlast))
        (if (< (- par tem) 50)(setq scl stp1))
        (if (< (- par tem) 10)(setq scl stp2))
        (command "_offset" scl deln pts "")
        (entdel deln)
        (setq deln(entlast))
        (command "_boundary" pts "")
        (command "_area" "_e" "_l")
        (setq par(getvar "area"))
       )
       (entdel deln)
 )
)
(command "_change" "_l" "" "_p" "_c" "_green" "")
(command "_boundary" ptb "")
(command "_change" "_l" "" "_p" "_c" "_red" "")
)
;******************************************************************************
(defun ready ()
 (princ scl)
 (princ "\nValeur dessin : ")
 (princ par)
 (princ "\nValeur theorique: ")
 (princ tem)
(setq *error* olderr)
(setvar "osmode" osm)
(setvar "cmdecho" 1)
(setvar "blipmode" 1)
(princ "\nFin ")
(princ)
);close defun

 

Bonne journée :)

[bonuscad]

Bonjour bonjour,

 

Voici le Lisp corrigé, même s'il n'est pas d'une rapidité incroyable il a au moins le mérite de fonctionner

 

 

Bonjour,

 

Intéressant, mais en effet cet méthode itérative n'est pas des plus rapide.

 

J'avais planché sur une division avec une surface donnée et parallèle à un coté donné en utilisant la formule de Saron.

Ça ne répons pas à toute les options que propose ton lisp, mais par contre il est beaucoup plus rapide (ce n'est pas un calcul itératif) et précis.

Je te le livre au cas ou il puisse t'être utile.

(defun ang_between (p10 p11 p20 p21 / px p1 p2 l_pt l_d p ang)
 (setq px (inters p10 p11 p20 p21 nil))
 (cond
(px
 	(if (> (distance px p10) (distance px p11)) (setq p1 p10) (setq p1 p11))
 	(if (> (distance px p20) (distance px p21)) (setq p2 p20) (setq p2 p21))
 	(setq
   	l_pt (list px p1 p2)
   	l_d (mapcar 'distance l_pt (append (cdr l_pt) (list (car l_pt))))
   	p (/ (apply '+ l_d) 2.0)
   	ang (* (atan (sqrt (/ (* (- p (car l_d)) (- p (caddr l_d))) (* p (- p (cadr l_d)))))) 2.0)
 	)
)
(T
 	nil
)
 )
)
(defun c:divide_saron ( / pt1 pt2 pt3 pt4 S1 ang1 ang2 x1 x2 ptx1 ptx2)
 (initget 1)
 (setq pt1 (getpoint "\nPremier point de la ligne de base: "))
 (initget 1)
 (setq pt2 (getpoint pt1 "\nSecond point de la ligne de base: "))
 (initget 1)
 (setq pt3 (getpoint pt1 "\nPoint sur le premier côté adjacent: "))
 (initget 1)
 (setq pt4 (getpoint pt2 "\nPoint sur le deuxième côté adjacent: "))
 (initget 7)
 (setq S1 (getreal "\nSurface désirée: "))
 (setq ang1 (ang_between pt1 pt2 pt1 pt3))
 (setq ang2 (ang_between pt2 pt1 pt2 pt4))
 (cond
((and ang1 ang2)
 	(setq ang1 (- pi ang1) ang2 (- pi ang2))
 	(setq x1
   	(*
     	(/
       	(* (distance pt1 pt2) (sin ang1))
       	(sin (+ ang1 ang2))
     	)
     	(1-
       	(+ ;ou peut être "-"
         	(sqrt
           	(1+
             	(/
               	(* 2.0 S1 (sin (+ ang1 ang2)))
               	(* (distance pt1 pt2) (distance pt1 pt2) (sin ang1) (sin ang2))
             	)
           	)
         	)
       	)
     	)
   	)
 	)
 	(setq x2 (/ (* x1 (sin ang2)) (sin ang1)))
 	(setq ptx1 (polar pt1 (angle pt1 pt3) x2))
 	(setq ptx2 (polar pt2 (angle pt2 pt4) x1))
 	(command "_.line" "_none" ptx1 "_none" ptx2 "")
)
(T (princ "\nIncorrect!"))
 )
 (prin1)
)

 

[Francis]

Merci pour ce petit code, malheureusement il ne marche pas chez moi...

 

Par contre ça pourrait être une piste à méditer, je vais me pencher dessus et voir avec d'autres outils mathématiques s'il n'y a pas moyen d'optimiser tout ça...

 

Merci beaucoup en tout cas :)

[bonuscad]

Merci pour ce petit code, malheureusement il ne marche pas chez moi...

 

Je vais essayer d'être un peu plus précis sur l'utilisation de celui-ci car je vois pas pourquoi il ne fonctionne pas!

Le prérequis et d'avoir une parcelle dont la surface recherchée doit être comprise dans un trapèze quelconque

c \ /d

\__ /

A B

Le "Premier point de la ligne de base: " sera par exemple A, le "Second point de la ligne de base: " sera B

le "Point sur le premier côté adjacent: " sera un point situé sur le segment Ac et le "Point sur le deuxième côté adjacent: " sera sur le segment Bd

Au delà de la partie haute de c et d le reste de la forme de la parcelle peut être quelconque.

La ligne dessiné sera parallèle à AB et les extrémités seront les intersections respectives (elles seront projetée au delà si les segments Ac et/ou Bd sont trop court) des côtés adjacents.

La surface de ce nouveau trapèze (dont les 2 bases sont parallèles) fera exactement la surface demandée.

 

Il est certain que si les côtés adjacents sont trop court, il faudrait répété l'opération avec la nouvelle ligne en indiquant la surface du/des triangle(s) qui est/sont soit en trop, soit en moins (suivant la direction du segment au delà des segments adjacent) pour obtenir la bonne surface avec la forme de la parcelle.

 

J'espère avoir été plus clair... après il est certain que ce code minimaliste ne peut répondre à toutes les situations, mais en tout cas le résultat n'est pas une approximation.

 

Voir la page 5 de ce document pour mieux comprendre

 

[Francis]

En effet, cela fonctionne parfaitement dans un trapèze et même dans des quadrilatères biscornus, je l'avais testé dans un polygone quelconque d'où le fait que cela ne fonctionne pas...

 

Ça me donne matière à réfléchir, est ce que cela te dérange si je l'incorpore dans une autre routine?

 

Mais intéressant ce formulaire, par contre je suis assez étonné de ne pas avoir vu cette formule de Sarron en BTS MGTMN (ou alors je n'étais pas assez assidu :(rires forts): )

[didier]

Coucou

 

Je suis en train de faire quelque chose qui va dans ce sens

Je vous proposerai ma version sans doute par un lien sur da-code

En ce moment j'ai pas trop envie de travailler, pardon pour le délai.

 

Amicalement

 

[lili2006]

Bonjour à toutes et tous,

Oui SARRON est plus utilisé en mathématique car utilise des angles orientés de proche en proche,..

Dés que l'on peut, en topo, on travaille avec les gisements, c'est surement pour ça que tu ne l'a pas vu en BTS,..

 

Je montre au moins une fois la "galère" avec SARRON par rapport à ce que l'on peut faire "très simplement" en utilisant les Gisements et les divisions de surface dans un quadrilatère quelconque,..

Tu peux aussi faire des régles de trois dans le triangle virtuel (prolongement des deux cotés non parallèles,..),...,...

 

Avec cet exemple, tu devrai vite être convaincu,..

[bonuscad]

cela te dérange si je l'incorpore dans une autre routine?

 

Non du tout, si je l'ai publié, c'est bien pour pouvoir en faire ce que l'on en veut, autrement je l'aurais compilé et non donné le code source.

Tiens hier soir, je regardais Arte avec l'historique de l'informatique, avec les premiers club qui s'échangeait les codes, en faisait des copies pour les distribuer.

Je suis encore dans cette époque, même si l'on a vu que certain on en tiré profit (je pense que vous voyez de qui je veux parler...)

 

Ces personnes sont toujours fiers de ce qu'elles ont put créer malgré pour récompense un emblématique tee-shirt, l'autre n'a qu'une fortune immense avec suspicion de voler encore nos données pour s'enrichir encore plus...

On a pas les mêmes valeurs

 

[lili2006]

Bonjour à toutes et tous,

Salut bonuscad,

On a pas les mêmes valeurs

 

Oh que non pour la plupart des membres de ce site,...

 

[didier]

Coucou

 

Méfiez-vous, Bill Guette ...

[Francis]

Bonjour bonjour,

 

Je ne pensais pas que mon post serait à l'origine de ce genre de discussions :(rires forts):

 

Je vous remercie pour vos réponses respectives ;)

 

Didier, je sais que je ne regarde pas assez votre site mais je pense que cela va changer en m’attaquant plus profondément aux boîtes DCL :(rires forts):

 

Lili, vos sujets sont bien intéressants, mais je trouve assez dommage de ne plus voir ce genre de choses en BTS (et même plus loin...).

 

Et merci bonuscad pour la mise à disposition, je vais voir si je peux en faire quelque chose voir coupler cette routine au sein de même programme... A méditer!

 

Bonne soirée!