Test failure in Pizza Pi

What am I supposed to do about this?

FAILED
Test 9
Calculates the diameter of a pizza from the amount of sauce applied (4/5)

CODE RUN
(is (= 32.573500793528d0 (size-from-sauce 250)))
(is (= 20.601290774570113d0 (size-from-sauce 100)))
(is (= 37.424103185095554d0 (size-from-sauce 330)))
(is (= 46.52426491681278d0 (size-from-sauce 510)))
(is (= 53.72159374714264d0 (size-from-sauce 680)))
TEST FAILURE

(SIZE-FROM-SAUCE 100)

 evaluated to 

20.60129077457011d0

 which is not 

=

 to 

20.601290774570113d0

I’m working in the web editor.

Not sure right now, I submitted my solution again to check if it’s still passing and it passed.
Can you please share your code?


This is off topic but since you wrote in another thread that you had a difficult time getting into lisp… I would have a hard time getting into Lisp as well if I would try it without good editor support and a REPL. And I already had a hard time getting into Lisp when I started out. :smiley:
Feel free to hit me up on slack if you need help with setting up an environment.

Since you’re an experienced Exercism user I assume you know but maybe someone else comes across this post and doesn’t know: You can download the exercise and submit a failing solution through the CLI. That way you can ask for mentorship.

Here’s my code. Perhaps the tests don’t need to compare to the 15th decimal place though…

(defpackage :pizza-pi
  (:use :cl)
  (:export :dough-calculator :pizzas-per-cube
           :size-from-sauce :fair-share-p))

(in-package :pizza-pi)

(defvar base-dough 200) ; amount of dough in grams for the "base" (i.e. non-crust) of the pizza
(defvar dough-per-length-of-crust 45) ; amount of dough in grams per length of crust
(defvar len 20)   ; size in cm of a "length of crust"

(defun perimeter (diameter) (* pi diameter))

(defun lengths-of-crust (diameter)
  (/ (perimeter diameter) len)
)
(defun crust-dough (diameter)
  (* (lengths-of-crust diameter) dough-per-length-of-crust)
)

(defun dough-calculator (pizzas diameter)
  (round (* pizzas (+ (crust-dough diameter) base-dough)))
)

(defvar sauce-unit 3/10) ; amount of sauce in mL per cm^2 of pizza

;; given an area of a circle, return the diameter
(defun diameter-from-area (area)
  ; a = pi r^2 => r = sqrt(a / pi) => d = 2 * sqrt(a/pi)
  (* 2 (sqrt (/ area pi)))
)

(defun size-from-sauce (sauce)
  (diameter-from-area (/ sauce sauce-unit))
)

;; n = (2 * (l^3))/(3 * pi * (d^2))
(defun pizzas-per-cube (cube-size diameter)
  (print (list 'numerator (* 2 cube-size cube-size cube-size)))
  (print (list 'denominator (* 3 * pi * diameter * diameter)))
  (/ (* 2 cube-size cube-size cube-size)
     (* 3 pi diameter diameter)
  )
)

(defun fair-share-p (pizzas friends))

Yeah, you’re running into a type conversion issue. My theory was that it’s a problem with defining the sauce-unit as a fraction but converting it to a float didn’t help.

+1 for not matching floating point numbers to the 15th decimal. :smiley: I learned that you should always only match up to a certain precision when testing floating-point numbers.

If you transfer the formula like it’s written in the problem description, without transforming it, your test should pass: square-root of ((40 * sauce-applied) / (3 * pi))

Since community contributions are currently paused I’ll leave my suggested fix here in the forum:

(defvar epsilon 0.00000001)

(defun compare-floats (float1 float2)
  (< (abs (- float1 float2)) epsilon))

(test splash-of-sauces "Calculates the diameter of a pizza from the amount of sauce applied"
  (is (compare-floats 32.573500793528d0 (size-from-sauce 250)
       ))
  (is (compare-floats 20.601290774570113d0 (size-from-sauce 100)))
  (is (compare-floats 37.424103185095554d0 (size-from-sauce 330)))
  (is (compare-floats 46.52426491681278d0 (size-from-sauce 510)))
  (is (compare-floats 53.72159374714264d0 (size-from-sauce 680))))
1 Like

Looks like a problem with floating point equality. Thought I had those solved in the exercises but it seems that I have not.

Sorry about this.

1 Like

Looking at another exercise that leans heavily on floats: space-age I see it was solved with:

(defun rounds-to (expected actual)
  (flet ((to-2-places (n) (/ (round (* 100 n)) 100.0)))
    (is (= (to-2-places expected) (to-2-places actual)))))

So that is how I’d likely fix it for pizza-pier (and should have been fixed with that in the first place :( )

2 Likes

PR opened and ready for review:

@glennj / @fap - would love either/both of your feedback on my proposed solution.

@glennj the fix to the exercise was merged so hopefully you should be seeing it on the web site. Has it fixed the problem? Can we mark this topic ‘solved’?