Fonction d'encadrement d'un nombre réel

[bonuscad]

Bonjour,

 

J'essaye d'écrire le plus simplement possible une fonction d'encadrement d'un nombre réel.

 

Mon problème majeur est que je veux qu'elle fonctionne avec les nombres POSITIF et aussi NEGATIF!

 

pour un nombre réel n je voudrais l'entier strictement supérieur suivant et l'entier inférieur ou égal précédent.

 

exemples d'encadrement:

 

5 > 4.3 >= 4

2 > 1.0 >= 1

1 > 0.5 >= 0

1 > 0.0 >= 0

0 > -0.75 >= -1

0 > -1.0 >= -1 (celui-ci par exemple n'est pas retourné de manière exacte par ma routine)

-1 > -1.25 >= -2

 

J'arrive pas à écrire quelque chose de correct pour les nombres négatifs (enfin pas simplement..., je dois être fatigué)

Un petit coup de pouce? Pour que la lumière fuse ;)

 

Voici par exemple où j'en suis, mais qui ne fonctionne pas si je fourni un entier sous forme de réel en négatif.

 

((lambda ( / )
(setq q_pr (getreal "\n Réel?: "))
(princ
(strcat "\n" (rtos q_pr 2 3)
	" >= "
	(rtos
		(if (< q_pr 0.0)
			(- (float (1+ (abs (fix q_pr)))))
			(float (fix q_pr))
		)
	)
)
)
(princ
(strcat "\n" (rtos q_pr 2 3)
	" < "
	(rtos
		(if (< q_pr 0.0)
			(- (float (abs (fix q_pr))))
			(float (1+ (fix q_pr)))
		)
	)
)
)
(prin1)
))

[(gile)]

Salut,

 

en m'inspirant des routines 'floor' et 'ceil'

 

;; floor
;; Retourne l'entier inférieur ou égal au nombre
(defun floor (d)
 ((lambda (n)
    (if (and (minusp d) (< d n))
      (1- n)
      n
    )
  )
   (fix d)
 )
)

;; ceil
;; Retourne l'entier supérieur ou égal au nombre
(defun ceil (d)
 ((lambda (n)
    (if (or (minusp d) (>= n d))
      n
      (1+ n)
    )
  )
   (fix d)
 )
)

 

Un truc qui devrait te convenir :

 

(defun foo (d)
 ((lambda (n)
    (list
      (if (and (minusp d) (< d n))
 (1- n)
 n
      )
      (if (> n d)
 n
 (1+ n)
      )
    )
  )
   (fix d)
 )
)

[bonuscad]

 

Un truc qui devrait te convenir :

 

(defun foo (d)
 ((lambda (n)
    (list
      (if (and (minusp d) (< d n))
 (1- n)
 n
      )
      (if (> n d)
 n
 (1+ n)
      )
    )
  )
   (fix d)
 )
)

 

En effet cela répond à mon désir, je vais pouvoir faire mes requêtes d'encadrement intelligentes pour map en lisp.

Merci beaucoup (gile), mais je pensais vraiment à plus basique pour faire cela...

[Patrick_35]

Salut

 

J'y vais aussi de ma petite routine.

(defun foo2 (d)
 (if (> d 0)
   (list (fix d)
  (1+ (fix d))
   )
   (list (1- (fix d))
  (fix d)
   )
 )
)

 

@+

[(gile)]

Salut

 

J'y vais aussi de ma petite routine.

(defun foo2 (d)
 (if (> d 0)
   (list (fix d)
  (1+ (fix d))
   )
   (list (1- (fix d))
  (fix d)
   )
 )
)

 

@+

 

Ça ne marche pas avec 0.0 et les nombre entiers négatifs...

[Patrick_35]

Je n'avais pas intégré avec des entiers, mais bon, pour le plaisir.

 

(defun foo2 (d)
 (if (or (>= d 0) (= (fix d) d))
   (list (fix d)
         (1+ (fix d))
   )
   (list (1- (fix d))
         (fix d)
   )
 )
)

 

@+

[bonuscad]

Je n'avais pas intégré avec des entiers, mais bon, pour le plaisir.

 

(defun foo2 (d)
 (if (or (>= d 0) (= (fix d) d))
   (list (fix d)
         (1+ (fix d))
   )
   (list (1- (fix d))
         (fix d)
   )
 )
)

 

@+

 

Ça le fait aussi, maintenant j'ai le choix.

En le voyant écrit, je me dis que j'aurais pus le trouver seul, mais franchement j'ai piétiné...

Merci à vous deux.

[(gile)]

Patrick_35,

 

Là oui !

Plus simple et élégant que ma bidouille ! ;)

[VDH-Bruno]

Bonsoir,

 

Ma variante sans or ni and ;-)

(defun foo1 (d) 
((lambda (n) 
  (if (minusp (- d n)) 
   (cons n (1- n)) 
   (cons (1+ n) n) 
  ) 
 ) 
 (fix d) 
) 
)

 

La même présenté différemment

(defun foo2 (d / n) 
 (if (minusp (- d (setq n (fix d)))) 
  (cons n (1- n)) 
  (cons (1+ n) n) 
 ) 
)

 

A+

[(gile)]

Encore mieux ! ;)

[bonuscad]

Ben avec tout ça, je vais bien réussir à faire quelque chose. B)

 

J'ai trouvé l'oubli dans mon code, j'ai fait la même erreur que Patrick_35: tester l'égalité de la partie entière avec le nombre pour obtenir les valeurs inclusives voulues.

 

En tout cas très instructif tous ces montages différents d'une fonction en somme basique.

[VDH-Bruno]

Bonjour,

 

En tout cas très instructif tous ces montages différents d'une fonction en somme basique.

 

Oui tout à fait Bonuscad car il n’y a que ce matin que je viens de réaliser en réfléchissant sur la troncature des nombres réels que (minusp (- d n)) <=> (> n d), des fois c’est avec des évidences que l’on se complique le plus la vie…

 

Donc:

(defun foo (d)
 ((lambda (n)
    (if (> n d)
      (cons n (1- n))
      (cons (1+ n) n)
    )
  )
   (fix d)
 )
)

 

Encore mieux ! ;)

Maintenant oui ! ;)

 

A+

[VDH-Bruno]

Re,

 

Bon dans la foulée et à chaud les fruits de mon extrapolation sur la question des encadrements et leurs relations…

 

 

Entier inférieur ou égal?

;; n?<=d
;; Retourne l'entier inférieur ou égal au nombre
(defun n?<=d (d)
 ((lambda (n) (if (> n d) (1- n) n))
  (fix d)
 )
)
;; ou (defun n?<=d (d) (1- (n?>d d)))

 

 

Entier strictement supérieur?

;; n?>d
;; Retourne l'entier strictement supérieur au nombre
(defun n?>d (d)
 ((lambda (n) (if (> n d) n (1+ n)))
  (fix d)
 )
)
;; ou (defun n?>d (d) (1+ (n?<=d d)))

 

 

Entier strictement inférieur?

;; n?<d
;; Retourne l'entier strictement inférieur au nombre
(defun n?<d (d)
 ((lambda (n) (if (<= d n) (1- n) n))
  (fix d)
 )
)
;; ou (defun n?<d (d) (1- (n?>=d d)))

 

 

Entier strictement supérieur ou égal?

;; n?>=d
;; Retourne l'entier strictement supérieur ou égal au nombre
(defun n?>=d (d)
 ((lambda (n) (if (<= d n) n (1+ n)))
  (fix d)
 )
)
;; ou (defun n?>=d (d) (1+ (n?<d d)))

 

 

(Ps : En conclusion si on connait n?<=d ou n?>d et n?<d ou n?>=d cela suffit pour définir tous les cas, comme dans les routines floor & ceil de (gile)).

 

A+

 

 

 

EDIT : Simplifié (< 0 (- d n)) par (>= n d) dans les 2 dernières fonctions en comparant avec la fonction ceil de (gile)

Modifié le 28 novembre 2012 par VDH-Bruno

[Patrick_35]

Bonjour,

 

 

 

Oui tout à fait Bonuscad car il n’y a que ce matin que je viens de réaliser en réfléchissant sur la troncature des nombres réels que (minusp (- d n)) <=> (> n d), des fois c’est avec des évidences que l’on se complique le plus la vie…

 

Donc:

(defun foo (d)
 ((lambda (n)
    (if (> n d)
      (cons n (1- n))
      (cons (1+ n) n)
    )
  )
   (fix d)
 )
)

 

 

Maintenant oui ! ;)

 

A+

Comme le dirait Bonus, à le voir écrit, cela saute au yeux

 

En le voyant écrit, je me dis que j'aurais pus le trouver seul, mais franchement j'ai piétiné...

C'est les fêtes qui commencent ;)

 

Quand ça m'arrive, je laisse tomber le code et je le reprends le lendemain. En général, au bout de 5mn, c'est bouclé.

 

@+