球拍-创建具有某些限制的水密度函数

Question

I am attempting to solve the following problem:

Lately, Finn has been very curious about buckets of ice water and their properties. He has been reviewing the density of water and ice. It turns out the density of water in both states depends on many factors, including the temperature, atmospheric pressure, and the purity of the water.

As an approximation, Finn has written the following function to determine the density of the water (or ice) in kg/m ³ as a function of temperature t in Celsius (−273.15 ≤ t ≤ 100):

 water-density(t) = ( 999.97 if t ≥ 0 ; 916.7 if t < 0 ) 

Write a function water-density that consumes an integer temperature t and produces either 999.97 or 916.7, depending on the value of t . However, you may only use the features of Racket given up to the end of Module 1.

You may use define and mathematical functions, but not cond , if , lists, recursion, Booleans, or other things we'll get to later in the course. Specifically, you may use any of the functions in section 1.5 of this page: http://docs.racket-lang.org/htdp-langs/beginner.html except for the following functions, which are not allowed: sgn , floor , ceiling , round .

This is what I have so far:

(define (water-density t)
  (+ (* (/ (min t 0) (min t -0.000001)) -83.27) 999.97))

This code does definitely work as long as the given temperature is not between -0.000001 and 0, but it will not work for temperatures between that range. What can I do to avoid this problem? Dividing by zero is the biggest problem I have here.

Answer 1

This is a somewhat.... interesting way of going about teaching programming, and I have a feeling this class is going to cause more StackOverflow questions to appear in the future, but you can do it by combining max and min to make a function that returns either 1 or 0 depending on whether its input is negative:

(define (negative->boolint n))
  (- 0
     (min 0
          (max (inexact->exact (floor n))
               -1))))

This function takes a number, rounds it down with (inexact->exact (floor n)) , then the combination of max and min "bounds" the number to be between -1 and 0, then subtracts that result from 1. Since after conversion to an integer the number can never be between -1 and 0, the bounding just results in 0 for positives and zero and -1 negatives. The subtraction part means the function returns (- 0 0) for all positive numbers and zero and returns (- 1 -1) for all negative numbers. By combining the result of this function with some arithmetic, you can get the behavior you want:

(define (water-density t)
  (- 999.97
     (* 83.27
        (negative->boolint t))))

If t is positive or zero, then the result of (* 83.27 (negative->boolint t)) will just be zero. Otherwise, the difference of the two densities will be subtracted, giving you the correct result.

This works because it's just taking advantage of max and min 's built-in conditional functionality to do conditional arithmetic. You could probably achieve the same with some level of hackery for round or abs or other statements that have conditional logic.

EDIT

My apologies, I missed the part of your question about not being able to use the rounding functions. Want you want is still doable however, by using two base functions for simulating conditionals: abs and expt . Getting conditionals from abs is fairly straightforward, you can divide a number by its absolute value to get it's sign. The reason you need expt is because it lets you get around the division by zero issue with abs , because (expt 0 x) is 0 for all positive numbers, 1 for zero, and undefined for negative numbers. We can use this to make a zero->boolint function:

(define (zero->boolint x)
  (expt 0 (abs x)))

With this, we can add its result to the numerator and denominator to get around division by zero in (/ x (abs x)) . Since this causes the division by zero case to return 1, we now have a nonnegative->boolint function:

(define (nonnegative->boolint x)
  (/ (+ 1
        (/ (+ (zero->boolint x) x)
           (+ (zero->boolint x) (abs x))))
     2))

The inner division takes care of dividing a number by its absolute value to return -1 for negatives and 1 for positives and zero. The outer addition by 1 and then division by 2 turns this into 0 for negatives and 1 for positives and zero. In order to get a negative->boolint function, we just need some sort of not operation - which in the case of 1 for true and 0 for false is just subtracting the value from 1. So we can define negative->boolint based on only the conditional logic of abs and expt as:

(define (negative->boolint x)
  (- 1 (nonnegative->boolint x))

This works as expected with the definition of water-density . Also, please don't ever do this in real world code. No matter how "clever" it may seem at the time.