5685 réponses à ce sujet

[A'arab Zaraq]

Coucou !

[Emma Indoril]

Bonjour les Échassiers !

[Korfandar]

C'était un puissance 4

Bonjour

Echassier := Bonjour + 1;

[Emma Indoril]

Un bonjour en puissance 4 ca donne quoi ?
Bonjour*Bonjour*Bonjour*Bonjour ? correct ?

[Korfandar]

Ben Bonjour⁴ mais ça marche aussi avec to proposition ou Bonjour²*Bonjour²

Mais là on est retombé à Bonjour¹

[Svartalfar]

Ah ouaiiiis !
J'en étais loin ! A la rigueur, si le X avait été remplacé par un O ou O..., j'aurais pu faire le lien. ^^

Bonjour

[Gilbertus]

Petit jeu pour les fanas du code

Quel est ce langage ?

% File:  TAYLOR.DIF
defun TAYLOR (EXPN, X, A, N % Local % ,J, C, ANS, NUMNUM, DENNUM),
  WHEN POSITIVE (N) OR ZERO (N)
    NUMNUM: DENNUM: 30,
    J: ANS: 0,
    C: 1,
    DOLOOP
      ANS: ANS + C * EVSUB (EXPN, X, A),
      WHEN J=N       ANS       EXIT,
      EXPN: DIF (EXPN, X),
      J: J + 1,
      C: C * (X-A) / J,
    ELOOP EXIT,
  LIST ('TAYLOR, EXPN, X, A, N)
endfun $

[Korfandar]

Ha oui je n'avais pas pensé à utiliser les couleurs...

Bonjour,

@Gilbertus, connais pas, je suis soit trop jeune soit trop vieux

[Emma Indoril]

Citation

Ben Bonjour⁴ mais ça marche aussi avec to proposition ou Bonjour²*Bonjour²

Rhaaa ! Les maths, les maths, les maths !


Bonjour

Dix jours.

Modifié par Emma Indoril, 17 février 2023 - 18:54.

[Gilbertus]

Concis
la fonction Fibonaci ou lart de la réentrance

function fib(x),
       cond ((x < 2, 1),
             (t,     fib (x-1) + fib (x-2))
            )
       endcond
endfun;

[Finraïl]

Salut.

Gilbertus, le 17 février 2023 - 08:25, dit :

Petit jeu pour les fanas du code

Quel est ce langage ?

% File:  TAYLOR.DIF
defun TAYLOR (EXPN, X, A, N % Local % ,J, C, ANS, NUMNUM, DENNUM),
  WHEN POSITIVE (N) OR ZERO (N)
NUMNUM: DENNUM: 30,
J: ANS: 0,
C: 1,
DOLOOP
  ANS: ANS + C * EVSUB (EXPN, X, A),
  WHEN J=N    ANS    EXIT,
  EXPN: DIF (EXPN, X),
  J: J + 1,
  C: C * (X-A) / J,
ELOOP EXIT,
  LIST ('TAYLOR, EXPN, X, A, N)
endfun $

J'ai cherché, j'ai pas trouvé
Je veux bien la réponse !

[Gilbertus]

Ce langage a été conçu avec un autre langage le lisp
Lisp — Wikipédia (wikipedia.org)

Il s'appelle Musimp
muMATH - Wikipedia

A l'origine écrit pour un processeur 6502 (apple II ) ou CP80 Je me suis amusé à le recréer dans les années 90 pour m'amuser en C puis C++

le fichier H pour donner une idée
/******************************************************************************/
/*                                                                            */
/* PROGRAM NAME: GPSIMP.H                                                     */
/* -------------                                                              */
/*                                                                            */
/* -------------                                                              */
/* COPYRIGHT:                                                                 */
/* ----------                                                                 */
/*      Copyright © 1991-2018 by PERFETTI Gilbert                           */
/*      All Rights Reserved                                                   */
/*      Permission is garanted for unrestricted non-commercial use            */
/*                                                                            */
/* LAST CORRECTION:          (95/02/25)                                       */
/* ---------------                                                            */
/*                                                                            */
/* REVISION LEVEL:  8.0.0    (2018/04/30)                                       */
/* ---------------                                                            */
/*                                                                            */
/******************************************************************************/
/*                                                                            */
/* WHAT THIS PROGRAM DOES:                                                    */
/* -----------------------                                                    */
/* GPSIMP = GILBERT PERFETTI Symbolic Interpretor Mathematical Program.             */
/*                                                                            */
/* WHAT YOU NEED TO COMPILE THIS PROGRAM UNDER OS2 :                          */
/* -------------------------------------------------                          */
/*                                                                            */
/*  REQUIRED FILES:                                                           */
/*  ---------------                                                           */
/*                                                                            */
/*    GPSIMP.C       - Source code                                            */
/*    GPSIMP_ALG.C      - Source code                                            */
/*    GPSIMP_ARI.C      - Source code                                            */
/*    GPSIMP_ARRY.C      - Source code                                            */
/*    GPSIMP_BLDS.C     - Source code                                            */
/*    GPSIMP_CNTL.C     - Source code                                            */
/*    GPSIMP_DMEM.C     - Source code                                            */
/*    GPSIMP_DRIV.C     - Source code                                            */
/*    GPSIMP_EVAL.C     - Source code                                            */
/*    GPSIMP_INT.C      - Source code                                            */
/*    GPSIMP_JUMP.C     - Source code                                            */
/*    GPSIMP_LIM.C      - Source code                                            */
/*    GPSIMP_MATH.C     - Source code                                            */
/*    GPSIMP_MATX.C     - Source code                                            */
/*    GPSIMP_NUMB.C     - Source code                                            */
/*    GPSIMP_OBJ.C      - Source code                                            */
/*    GPSIMP_PARS.C     - Source code                                            */
/*    GPSIMP_SCAN.C     - Source code                                            */
/*    GPSIMP_SOLV.C     - Source code                                            */
/*    GPSIMP_SYMB.C     - Source code                                            */
/*    GPSIMP_TRIG.C     - Source code                                            */
/*    GPSIMP_WRIT.C     - Source code                                            */
/*    MUsimp.h       - Application Header File                                */
/*    GPSIMP_SYMB.H     - Global Variable and Program pattern Header File        */
/*                                                                            */
/*    STRING.H       - String function declarations                           */
/*    STDLIB.H       - Commonly used library function                         */
/*    STDIO.H        - Standard INPUT-OUTPUT routines                         */
/*    CTYPE.H        - Character conversions macros and ctype macros          */
/*    SETJMP.H       - Setjmp/longjmp routines                                */
/*    MATH.H         - Math library                                           */
/*                                                                            */
/***********************************************************************/
/*                                                                     */
/*                  Include the C library header files                 */
/*                                                                     */
/***********************************************************************/
/* Permet ‚valuation comme dans la documentation MUSIMP
   Ce mode d'‚valuation est beaucoup moins performant que le mode
   classique (r‚entrance, r‚curence ????) 3 … 4 fois plus lent
   Vu le peu de performance de cette m‚thode elle a ‚t‚ abandonn‚e.
   Ont ‚t‚ gard‚es les d‚finitions complŠtes MUSIMP.
   Par contre elles ne sont pas activ‚es puisque toutes les
   occurences internes ont ete supprimees notamment … chaque fois
   que l'on avait appel aux fonctions GPsimpEval et GPsimpApply.

#define evalmusimp     TRUE
*/


/* Permet utilisation de _printf = T pour editer les valeurs des
   variables avec la fonction stdprintf("", x)

#define debug          TRUE
*/

/* Permet de differer l'evaluation des arguments lorsque la fonction
   possede une property list.

#define DiffereEval     TRUE
*/
/* Permet utilisation des Names Descriptors,
   Il semble que cette utilisation des Names Descriptors soit
   l‚gŠrement moins performante que la non utilisation (environ 5 %)

#define namedescriptor TRUE
*/

/* Permet utilisation du Module arith.mus.
          utilisation du Module algebra.ari.
          utilisation du Module array.ari.
          utilisation du Module matrix.arr
          utilisation du Module trgpos.alg
          utilisation du Module trgneg.alg
          utilisation du Module log.alg
          utilisation du Module dif.alg
          utilisation du Module sigma.alg
          utilisation du Module eqn.alg
          utilisation du Module solve.eqn
          utilisation du Module lim.dif
          utilisation du Module int.dif
          utilisation du Module intmore.int
   ceci permet d' ameliorer les temps de reponse des calculs.
*/
#define UseGPsimpModules     TRUE


/******************    Standard libraries  ************************/
#include <stdio.h>
#include <ctype.h>
#include <setjmp.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>

#undef  EOF
#define EOF 0xFF
#define FLOAT            double
#define LFLOAT           long double
#define FIXENT           long int            // (big number)
#define FLONUM           double
#define LFLONUM          long double
#define LLNUM            long long           // affichage %lld
#define ULLNUM           unsigned long long  // affichage %llu
#define UBYTE            unsigned char
#define SBYTE            signed char
#define BOOLEAN          int
#define FALSE            0
#define TRUE             -1
#define NIL              (NODE *)0
#define HIGHVALUE        (NODE *)0xFF

/* program limits */
#define STRMAX          512   /* maximum length of a string constant */
#define SCRWIDTH         78   /* largeur ecran - 2                   */
#define HSIZE           199   /* symbol hash table size              */

/* Mathematical long integer definitions */
#define MAXCOMMA 10            /* nbr blocs 4 chiffres pour DIVIS    */
#define INF      (FIXENT)-1    /* a < b dans in_compare              */
#define EQU      (FIXENT)0     /* a = b dans in_compare              */
#define SUP      (FIXENT)1     /* a > b dans in_compare              */
#define FZERO    (FLOAT)0.0    /* Valeur 0                           */
#define FONE     (FLOAT)1.0    /* Valeur 1                           */
#define FTWO     (FLOAT)2.0    /* Valeur 2                           */
#define FTHREE   (FLOAT)3.0    /* Valeur 3                           */
#define FTEN     (FLOAT)10.0   /* Valeur 10                          */
#define FHUNDRED (FLOAT)100.0  /* Valeur 100                         */
#define FBASE    (FLOAT)1000000.0 /* 10^6   Base de calcul decimale  */
#define FINVBASE (FLOAT)0.000001  /* 10^-6  Base de calcul decimale  */
#define LFBASE    (LFLOAT)1000000.0 /* 10^6 Base de calcul decimale  */
#define LFINVBASE (LFLOAT)0.000001  /* 10^-6Base de calcul decimale  */
#define HFBASE   (FLOAT)100000.0  /*  2^20 Base de calcul hexa       */
#define ZERO     (FIXENT)0     /* Valeur 0                           */
#define ONE      (FIXENT)1     /* Valeur 1                           */
#define TWO      (FIXENT)2     /* Valeur 2                           */
#define THREE    (FIXENT)3     /* Valeur 3                           */
#define FOUR     (FIXENT)4     /* Valeur 4                           */
#define FIVE     (FIXENT)5     /* Valeur 5                           */
#define SIX      (FIXENT)6     /* Valeur 6                           */
#define SEVEN    (FIXENT)7     /* Valeur 7                           */
#define TEN      (FIXENT)10    /* Valeur 10                          */
#define HUNDRED  (FIXENT)100   /* Valeur 100                         */
#define NBASE    (FIXENT)6     /* Nombre de chiffres par blocs       */
#define BASE     (FIXENT)1000000   /*10^6 Base de calcul decimale    */
#define F101     (FLOAT)1.01
#define MODULO 1              /* modulo         = dividende%diviseur */
#define ENTIER 2              /* quotient INT   = dividende/diviseur */
#define FRACTION 3            /* quotient FLOAT = dividende:diviseur */
#define ASCII0   0x30

#define REGISTER register

/* node types */
#define FREE     0
#define SUBR     2 // 10
#define FSUBR    4  // 100
#define LIST     6 // 110
#define NAM      8                  // 1000   symbol NAME  
#define ENT      10 // 1010
#define STR      12                 // 1100   string NAME
#define FPTR     14 // 1110
#define VECT     16 // 10000
#define BIGNUM   18                 // 10010  symbol NUMBER
#define OBJ      20                 // 10100
#define NFLONUM  22                 // 11000  symbol FLOAT NUMBER
#define NLFLONUM 24                 // 11010  symbol LFLOAT NUMBER
#define NLLNUM   26                 // 11100  symbol LL NUMBER
#define NULLNUM  28                 // 11110  symbol ULL NUMBER
#define NFIXTYP  30                 // 100000 symbol long  
#define NRATNUM  32                 // 100010 symbol RATIO NUMBER
#define NCMPXNUM 34                 // 100100 symbol COMPLEX NUMBER

/* node flags */
#define MARK     1
#define LEFT     2

/* string subtype */
#define DYNAMIC  0
#define STATIC   1
#define OBJECT   2

/* Number subtype */
#define POSITIF  (SBYTE)1
#define NEGATIF  (SBYTE)-1

/* new node access macros */
#define gettype(x)          ((x)->n_type)
#define settype(x,v)        ((x)->n_type = (v))
#define setflags(x,v)       ((x)->n_flags = (v))
#define getorflags(x,v)     ((x)->n_flags | (v))
#define setorflags(x,v)     ((x)->n_flags |= (v))
#define getandflags(x,v)    ((x)->n_flags & (v))
#define setandflags(x,v)    ((x)->n_flags &= (v))
#define getnbsign(x)        ((x)->n_sign)
#define setnbsign(x,v)      ((x)->n_sign    = (v))

/* macro to create and set name to NIL */
#define LispEnterStaticValueNilName(x, y) \
        {(x) = LispEnterStaticName((y)); setnmcval((x), NIL);}
#define LispEnterStaticValueName(x, y, v)\
        {(x) = LispEnterStaticName((y)); setnmcval((x), (v));}

/* macros to protect node pointers in evaluation stack */
#define GPsimpStackCheck(n)  {if (GPsimpStack - (n) < GPsimpStackBase)\
                                 GPsimpStackOverflow();}
#define GPsimpSaveInStack(n) { *--GPsimpStack = &n; n = NIL;}
#define GPsimpProtectStack(n){ *--GPsimpStack = &n;}
#define GPsimpSaveInStack1(n){if (GPsimpStack <= GPsimpStackBase) \
                                 GPsimpStackOverflow();\
                             *--GPsimpStack = &n;\
                             n = NIL;}

/* macros to protect node pointers in evaluation stack */
#define GPsimpStackValueCheck(n)  {if (GPsimpStackValue - (n) < GPsimpStackValueBase)\
                                 GPsimpStackValueOverflow();}
#define GPsimpProtectStackValue(n){ *--GPsimpStackValue = &n;}
#define GPsimpSaveInStackValue(n) { *--GPsimpStackValue = &n; n = NIL;}

#define EnterName(x,px)  ((x) = LispEnterStaticName((px)))

#define EnterNameLbpRbp(x,px,lbp,rbp) \
   {(x) = LispEnterStaticName((px));\
   putprop(s_lbp, (x), cvfixnbr((lbp), POSITIF));\
   putprop(s_rbp, (x), cvfixnbr((rbp), POSITIF));}

#define EnterNameAndPushDelimiter(x, px) \
   {(x) = LispEnterStaticName((px)); push((x),    s_delimiter);}

/* uniquement les bignumbers */
#define getnumber(ix,x) \
((ix) = (getnbsign((x)) == POSITIF \
                     ?  getfixint(getnbpint((x))) \
                     : -getfixint(getnbpint((x))) ))

#define setnumber(ix) \
((ix) < 0 ? cvfixnbr(-(ix), NEGATIF) : cvfixnbr((ix),  POSITIF))

#define setgoodsign(z)\
{if (getnextint(getnbpint((z))) == NIL &&\
     getfixint(getnbpint((z))) == ZERO)\
    setnbsign((z), POSITIF);}

/* type de nombre  */
#define fixtypnump(x)     (ntype(x) == NFIXTYPNUM)
#define flonump(x)        (ntype(x) == NFLONUM)
#define lflonump(x)       (ntype(x) == NLFLONUM)
#define llnump(x)         (ntype(x) == NLLNUM)
#define ullnump(x)        (ntype(x) == NULLNUM)
#define ratiop(x)         (ntype(x) == NRATNUM)
#define complexp(x)       (ntype(x) == NCMPXNUM)

#define numberp(x)       ((x) && (x)->n_type == BIGNUM)
/*
#define numberp(x)       ( (x) && ((x)->n_type == BIGNUM) ||\
   (x)->n_type == NFLONUM ||\
                        (x)->n_type == NLFLONUM ||\
   (x)->n_type == NLLNUM ||\
                           (x)->n_type == NULLNUM ||\
                           (x)->n_type == NRATNUM ||\
                           (x)->n_type == NCMPXNUM ||\
   (x)->n_type == NFIXTYP)
*/
// ajouter eventuellement au dessus FIXTYP et RATIO et COMPLEX
#define namep(x)         ((x) && (x)->n_type == NAM)
#define emptyp(x)        ((x) == NIL)
#define LispAtom(x)      ((x) == NIL || (x)->n_type != LIST)
#define atomp(x)         (emptyp(x) || numberp(x) || namep(x))
#define listp(x)         (emptyp(x) || (x)->n_type == LIST)
#define adjoinp(x)       ((x)  && (x)->n_type == LIST)
#define subrp(x)         ((x)  && (x)->n_type == SUBR)
#define fsubrp(x)        ((x)  && (x)->n_type == FSUBR)
#define stringp(x)       ((x)  && (x)->n_type == STR)
#define filep(x)         ((x)  && (x)->n_type == FPTR)
#define vectorp(x)       ((x)  && (x)->n_type == VECT)
#define objectp(x)       ((x)  && (x)->n_type == OBJ)
#define funsubrp(x)      (namep((x)) && \
                         (subrp(getnmfval((x)))))
#define funfsubrp(x)     (namep((x)) && \
                         (fsubrp(getnmfval((x)))))
#define funxsubrp(x)     (namep((x)) && \
                         (subrp(getnmfval((x)))||fsubrp(getnmfval((x)))))
#define funlistp(x)      (namep((x)) && (adjoinp(getnmfval((x)))))

/* adjoin access macros */
#define car(x)           ((x)->n_car)
#define cdr(x)           ((x)->n_cdr)
#define consa(x)         adjoin((x), NIL)
#define consd(x)         adjoin(NIL, (x))
#define rplaca(x,y)      ((x)->n_car = (y))
#define rplacd(x,y)      ((x)->n_cdr = (y))

#ifdef namedescriptor
/* NAME Node with Descriptor */
#define d_nmpnode       n_Info.n_xsym.nm_pnode
#define n_nmcval        n_Info.n_xsym.nm_value
#else
/* NAME node without Descriptor */
#define n_nmpnode       n_Info.n_xsym.nm_pnode
#define n_nmcval        n_Info.n_xsym.nm_value
#endif


#ifdef namedescriptor
/* NAME major access macros with Descriptor */
#define getnmcval(x)      ((x)->n_nmcval)
#define setnmcval(x,v)    ((x)->n_nmcval = (v))
#define getnmpval(x)      ((x)->d_nmpnode->nm_plist)
#define setnmpval(x,v)    ((x)->d_nmpnode->nm_plist  = (v))
#define getnmfval(x)      ((x)->d_nmpnode->nm_pfval)
#define setnmfval(x,v)    ((x)->d_nmpnode->nm_pfval  = (v))
#define getnmpname(x)     ((x)->d_nmpnode->nm_pname)
#define setnmpname(x,v)   ((x)->d_nmpnode->nm_pname = (v))
#define getnmtype(x)      ((x)->d_nmpnode->nm_type)            // not used
#define setnmtype(x,v)    ((x)->d_nmpnode->nm_type = (v))      // not used
#else
/* NAME major access macros without Descriptor */
#define getnmcval(x)   ((x)->n_nmcval)
#define setnmcval(x,v) ((x)->n_nmcval = (v))
#define getnmpval(x)   ((x)->n_nmpnode->n_car)
#define setnmpval(x,v) ((x)->n_nmpnode->n_car  = (v))
#define getnmfval(x)   ((x)->n_nmpnode->n_cdr->n_car)
#define setnmfval(x,v) ((x)->n_nmpnode->n_cdr->n_car = (v))
#define getnmpname(x)  ((x)->n_nmpnode->n_cdr->n_cdr)
#define setnmpname(x,v)((x)->n_nmpnode->n_cdr->n_cdr = (v))
#endif

/* LIST node */
#define n_car           n_Info.n_xlist.xl_car
#define n_cdr           n_Info.n_xlist.xl_cdr

/* NAME string node */
#define n_strtype       n_Info.n_xstr.xst_type
#define n_pstr          n_Info.n_xstr.xst_pstr

/* NAME minor access macros */
#define getpstr(x)     ((x)->n_pstr)
#define setpstr(x,v)   ((x)->n_pstr = (v))

/* NAME subr/fsubr node */
#define n_subr          n_Info.n_xsubr.xsu_subr

/* NAME subr/fsubr access macros */
#define getsubr(x)       ((x)->n_subr)
#define setsubr(x,v)     ((x)->n_subr = (v))

/* NUMBER integer node */
#define n_Int         n_Info.n_xint.xi_Int
#define n_nextint     n_Info.n_xint.xi_nextint

/* NUMBER unsigned long long integer node */
#define n_ull         n_Info.n_xull.xi_ull
#define n_nextull     n_Info.n_xull.xi_nextull

/* NUMBER long long integer node */
#define n_ll          n_Info.n_xll.xi_ll
#define n_nextll      n_Info.n_xll.xi_nextll

/* NUMBER long long float node */
#define n_lfloat      n_Info.n_xlfloat.xi_lfloat
#define n_nextlfloat  n_Info.n_xlfloat.xi_nextlfloat

/* NUMBER long float node */
#define n_float       n_Info.n_xfloat.xi_float
#define n_nextfloat   n_Info.n_xfloat.xi_nextfloat

/* NUMBER node */
#define n_nbcval      n_Info.n_xbignum.nb_value
#define n_nbpnode     n_Info.n_xbignum.nb_pnode

/* rational number node */
#define n_numer       n_info.n_xratio.xi_numer
#define n_denom       n_info.n_xratio.xi_denom

/* complex number node */
#define n_realpar     n_info.n_xrealpar.xi_realpar
#define n_imagpar     n_info.n_ximagpar.xi_imagpar

/* rational number access macros */
#define getnumer(x)        ((x)->n_numer)
#define getdenom(x)        ((x)->n_denom)

/* complex number access macros */
#define realpart(x)        ((x)->n_realpar)
#define imagpart(x)        ((x)->n_imagpar)



/* NUMBER major access macros */
#define getnbcval(x)   ((x)->n_nbcval)
#define setnbcval(x,v) ((x)->n_nbcval  = (v))
#define getnbpint(x)   ((x)->n_nbpnode)
#define setnbpint(x,v) ((x)->n_nbpnode = (v))

/* NUMBER minor access macros */
#define getfixint(x)    ((x)->n_Int)
#define setfixint(x,v)  ((x)->n_Int = (v))
#define getnextint(x)   ((x)->n_nextint)
#define setnextint(x,v) ((x)->n_nextint = (v))

#define getull(x)    ((x)->n_ull)
#define setull(x,v)  ((x)->n_ull = (v))
#define getnextull(x)   ((x)->n_nextull)
#define setnextull(x,v) ((x)->n_nextull = (v))

#define getll(x)    ((x)->n_ll)
#define setll(x,v)  ((x)->n_ll = (v))
#define getnextll(x)   ((x)->n_nextll)
#define setnextll(x,v) ((x)->n_nextll = (v))

#define getfloat(x)    ((x)->n_float)
#define setfloat(x,v)  ((x)->n_float = (v))
#define getnextfloat(x)   ((x)->n_nextfloat)
#define setnextfloat(x,v) ((x)->n_nextfloat = (v))

#define getlfloat(x)    ((x)->n_lfloat)
#define setlfloat(x,v)  ((x)->n_lfloat = (v))
#define getnextlfloat(x)   ((x)->n_nextlfloat)
#define setnextlfloat(x,v) ((x)->n_nextlfloat = (v))

/* FILE pointer node */
#define n_fp            n_Info.n_xfptr.xf_fp
#define n_savech        n_Info.n_xfptr.xf_savech

/* FILE access macros */
#define getfile(x)       ((x)->n_fp)
#define setfile(x,v)     ((x)->n_fp = (v))
#define getsavech(x)     ((x)->n_savech)
#define setsavech(x,v)   ((x)->n_savech = (v))

/* VECTOR node */
#define n_vsize         n_Info.n_xvect.xv_size
#define n_vdata         n_Info.n_xvect.xv_data

/* VECTOR access macros */
#define getvsize(x)       ((x)->n_vsize)
#define setvsize(x,v)     ((x)->n_vsize = (v))
#define getvdata(x,i)     ((x)->n_vdata[i])
#define setvdata(x,i,v)   ((x)->n_vdata[i] = (v))

/* OBJECT access macros */
#define getclass(x)     ((x)->n_vdata[0])
#define getivar(x,i)    ((x)->n_vdata[i+1])
#define setivar(x,i,v)  ((x)->n_vdata[i+1] = (v))

/* macro to check for the end of the argument list */
#define LispLastArgument(x) \
        {if ((x)) GPsimpToomany((x));}

/* Print macros */
#define put_linefeed(fptr)    {put_char((fptr),'\n');}

#define LBSIZE  200

/* execution context flags */
#define CF_GO            1
#define CF_RETURN        2
#define CF_THROW         4
#define CF_ERROR         8
#define CF_CLEANUP       16
#define CF_CONTINUE      32
#define CF_TOPLEVEL      64
#define CF_EXIT          128

/* node structure */
typedef struct node {
    UBYTE n_type;                /* type of node    */
    UBYTE n_flags;               /* flag bits       */
    SBYTE n_sign;                /* sign for number */
    UBYTE n_filler;              /* not used        */
    union {                      /* value           */
#ifdef namedescriptor
/* With Descriptor Node */
         struct xsym {          /* access symbol descriptor */
             struct descript *nm_pnode;  /* descriptor name pointer */
             struct node     *nm_value;  /* node current value pointer  */
             } n_xsym;
#else
/* Without Descriptor Node */
         struct xsym {          /* access symbol node */
             struct node     *nm_pnode;  /* node name ptr */
             struct node     *nm_value;  /* node current value ptr  */
             } n_xsym;
#endif
         struct xbignum {           /* access number node */
             struct node     *nb_pnode;  /* node number ptr  */
             struct node     *nb_value;  /* node number  value ptr  */
             } n_xbignum;
         struct xsubr {          /* subr/fsubr node */
             struct node     *(*xsu_subr)(); /* ptr internal routine */
             } n_xsubr;
         struct xlist {          /* list node (adjoin) */
             struct node     *xl_car;        /* car ptr */
             struct node     *xl_cdr;        /* cdr ptr */
             } n_xlist;
         struct xint {         /* long integer node  */
             struct node     *xi_nextint;    /* next int node */
             FIXENT           xi_Int;        /* int value */
             } n_xint;
         struct xull {       /* unsigned long long entier  64 bits */
             struct node     *xi_nextull;    /* next long unsigned long entier node */
             ULLNUM           xi_ull;         /* unsigned long long value */
             } n_xull;
         struct xll {        /* long long entier  64 bits */
             struct node     *xi_nextll;    /* next long unsigned long entier node */
             LLNUM           xi_ll;        /* unsigned long long value */
             } n_xll;
         struct xfloat {       /* float node  */
             struct node     *xi_nextfloat; /* next long node */
             FLONUM           xi_float;      /* long value */
             } n_xfloat;
         struct xlfloat {       /* lfloat node  */
             struct node     *xi_nextlfloat; /* next long long node */
             LFLONUM          xi_lfloat;     /* long long value */
             } n_xlfloat;
         struct xfixnum {       /* fixnum node */
             LLNUM     xi_fixnum;  /* fixnum value */
             } n_xfixnum;
         struct xratio {   /* rational number (ratio) node */
             LLNUM       xi_numer;   /* numerator */
             LLNUM       xi_denom;   /* denominator */
             } n_xratio;
         struct xcomplex {   /* rational number (ratio) node */
             LLNUM       xi_realpar;   /* partie reelle */
             LLNUM       xi_imagpar;   /* partie imaginaire */
             } n_xcomplex;
         struct xstr {           /* string node */
             int              xst_type;      /* string type */
             UBYTE           *xst_pstr;      /* string pointer */
             } n_xstr;
         struct xfptr {       /* file pointer node */
             int   xf_savech; /* lookahead character for input files */
             FILE *xf_fp;     /* the file pointer */
             } n_xfptr;
         struct xvect {          /* vector node */
             int              xv_size; /* vector size */
             struct node    **xv_data; /* vector data */
             } n_xvect;
    } n_Info;
} NODE;
#define PNODE NODE far *

#ifdef namedescriptor
/* descriptor structure (structure specifique pour NAME) */
typedef struct descript {
    UBYTE nm_type;           /* type of node not used              */
    UBYTE nm_filler[3];      /* for future use                     */
    struct node *nm_plist;   /* node LIST pointer                  */
    struct node *nm_pfval;   /* node LIST SUBR FSUBR pointer       */
    UBYTE       *nm_pname;   /* string pointer                     */
} DESCRIPT;
#define PDESCRIPT DESCRIPT *
#endif

/* execution context */
typedef struct context {
    int     c_flags;                   /* context type flags */
    struct  node *c_Expr;              /* expression (type dependant)*/
    jmp_buf c_jmpbuf;                  /* longjmp context */
    struct  context *c_GPsimpContext;  /* old value of xlcontext */
    struct  node ***c_GPsimpStack;     /* old value of xlstack */
    struct  node *c_GPsimpEnv;         /* old value of xlenv */
    long    c_GPsimpTrace;             /* old value of xltrace */
} CONTEXT;

[Svartalfar]

En gros, c'est un algo' de calcul pour les vieux Mac et DOS ?

Bonjour

[Gilbertus]

exact mais ses descendant sont nombreux

Maxima, Derive, Reduce et wxmaxima tiennent la dragée haute aux logiciels payants que sont Mathematica, Maple et Octave dans le domaine des mathématiques symboliques

[Korfandar]

C'est du LISP à la base ? Houla faut vraiment que je me replonge dans mes cours d'école d'ingénieur, d'il y a... Ha oui le temps passe vite quand même

Bonjour

[A'arab Zaraq]

Salut !

Le temps passe moins vite ici qu'ailleurs.

[Svartalfar]

Et encore, ailleurs sur internet la mode des téléphones à clapet revient. On n'est pas à l'abri que leurs rétropédalages temporels nous propulsent dans le futur.

Bonsoir

[Emma Indoril]

Si je pouvais être téléporté en 1978, je ne me gênerais pas. J'ai des parties de cachette à rattraper.

[Korfandar]

Retour du vinyle (passe encore), de la cassette (non mais là WTF ?????), mode vintage, voiture au design semi-retro (ça peut être bien mais ça peut être nul aussi), déco vintage (tant qu'on revient pas aux papiers peints des années 70) et le pire mentalité et politique vintage ! Vive le monde d'après...

Bonjour,

P.S. rappelez vous je suis un VGM !!!!

[A'arab Zaraq]

Il y a aussi la mode vestimentaire des années 90. Une réussite.

Salut !

Emma Indoril, le 20 février 2023 - 23:28, dit :

Si je pouvais être téléporté en 1978, je ne me gênerais pas. J'ai des parties de cachette à rattraper.

Pareil, je viserais aussi 1978. 10 ans avant ma naissance, ça me laisserait du temps pour planifier les bêtises à refaire dans ma vie, et en ajouter de nouvelles.

Modifié par A'arab Zaraq, 21 février 2023 - 12:06.

[Gilbertus]

Je n'ai aucune envie d'être téléporter à aucune époque quelconque de ma vie, refaire un parcours scolaire ou retravailler peu pour moi

[Svartalfar]

Si tu reviens avec un almanach, tu pourras parier sur des courses ou des matchs déjà joués en ton temps, te faire plein d'oseille et n'avoir aucunement besoin de travailler ou de faire des études...

Bonjour.

[Gilbertus]

Tu as trop vu "Retour vers le futur"

[D.A.D.]

Bonjour du futur en retard !

[Svartalfar]

Si peu. Ca reste la base des voyages dans le temps après.

D.A.D., le 21 février 2023 - 19:30, dit :

Bonjour du futur en retard !

Du retro-futur alors ?

Modifié par Svartalfar, 21 février 2023 - 19:37.