when interacting in the REPL, where do stdout logging statements show up?

To stdout

Which may or may not be the same as *out* for the repl

There are a few different clojure repls, the two main ones are clojure.main/repl and nrepl

How do I convert "123" to int 123 in clojure ("123" "456") => [123 456] (Integer. "123")?

(Long/parseLong "123")

If you're using the new 1.11 beta or rc versions you can check (apropos "parse") and see that there are some handy new parsing functions for exactly this purpose. (parse-long "123"). But this is only available in the upcoming release, and not in the stable releases 1.10.3 or below.

thanks

How can I write like this (a ? foo1 : foo2) in Clojure?

(if a foo1 foo2)

hello, does clojure.tools.logging can log the line number and the function name of the code

@haiyuan.vinurs Logging can produce filename and line number but that adds an overhead -- see the docs for the particular (Java) logging implementation you are using. It won't be able to figure out the Clojure function name because logging generally extracts that information from stacktraces and they'll be formatted for the compiled-to-Java-bytecode names at best.

At work, we include the namespace in the log format and we try to ensure that messages in logging calls are unique enough within a namespace to be able to find them easily.

I've never written tests for functions returning floating point values, so I'm wondering how I should test that a value is close enough to 0 or N.

I wrote this simple function

(defn polar-to-cartesian
  "polar to cartesian coordinates"
  [radius angle]
  [(* radius
      (m/cos angle))
   (* radius
      (m/sin angle))])

And this test

(deftest polar-to-cartesian-test
  (testing "Points on a circle at various angles"
    (is (= [1.0 0.0]
           (polar-to-cartesian 1 0)))
    (is (= [0.0 1.0]
           (polar-to-cartesian 1 (/ m/PI 2))))))

The problem is with that last expression

(polar-to-cartesian 1 (/ m/PI 2)) => [6.123233995736766E-17 1.0]

I get a value for the x coordinate that is close to, but not zero. So I tried stealing the ulp= function from clojure.math but I guess the value isn't close enough to zero?

(defn ulp=
  "Tests that y = x +/- m*ulp(x)
   Borrowed from: "
  [x y ^double m]
  (let [mu (* (m/ulp x) m)]
    (<= (- x mu) y (+ x mu))))

(ulp= 0.0 (get (pt-on-circle 1 (/ m/PI 2)) 0) 1) => false

The ulp bounds for math ops only specific to one op - when you are combining ops, the differences could be larger

How close is the value you're getting?

6.123233995736766E-17

I'm new to testing floating point stuff in general, so maybe a good question for you experts is "How close to a target value is conventionally considered close enough?"

It can depend a lot of the application, as errors accumulate

Ahh, interesting.

In general, you define a delta value, and check for: (> delta (abs (- expected actual))

@ericdlaspe Expectations has an approximately predicate for things like that: https://github.com/clojure-expectations/clojure-test/blob/develop/src/expectations/clojure/test.cljc#L475-L480 so you could write something like:

(defexpect polar-to-cartesian-test
  (expecting "Points on a circle at various angles"
    (expect (more-of [x y] (approximately 1.0) x (approximately 0.0) y)
            (polar-to-cartesian 1 0))
    ...))

Ok, that makes sense. Thank you, all.

So, when I'm doing FP math generally, I need to think about how many operations are done at once and decide when and how to do rounding to keep the errors acceptable?

The value of delta can vary, depending on the operation. A single operation, and you can make delta very small. But as you increase how many operations are involved, then the value for delta will need to grow. A single cos or sin should just need something in the order of 1e-15

(sorry, I have to leave for a bit)

There are entire courses on this subject. Acceptable errors, numerical stability, etc. just pointing out there's no simple answer and you're done

No worries. Thanks so much, @quoll!

It depends a lot on the particular situation. For example, in accounting, there are specific rules for rounding.

Ah, I can imagine. 🙂

I'm just playing around with graphics for now, but I'll keep that in mind and try to adhere to some kind of best practices... after I read more on the subject.

A general rule for rounding would be: "Use the maximum precision you can for most of the calculations, and round only on 'output'".

Rounding has its own issue, independent of the imprecision errors we were discussing earlier.

I'll study those a bit. Coming from C++, I've heard tales of various floating point oddities, but I was always safe with my area just being bit twiddling and integer math. I assume every language has similar but different FP challenges, so I'll just have to get familiar with Clojure's.

If you havent already, read this canonical reference. https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html

And this, for Clojure https://clojure.org/guides/equality#numbers

And with that, I'm off to read. Thank you all, @alexmiller @quoll @seancorfield @dpsutton and @dorab!

Hi. I’d like to take-while but include the first item that fails the predicate. What’s the right way to do that?

I’d hesitate to say “right” way. There are lots of ways to do it. Sometimes the simplest way is the best. One way would be to use take-while into a collection that can be appended to, and then get the next item: (conj (into [] (take-white pred collection)) (first (drop-while pred collection))) But maybe you don’t want to process the seq twice. So consider what you see when you do (source take-while) and just look at the 2 arity version:

=> (source take-while)
(defn take-while
  "Returns a lazy sequence of successive items from coll while
  (pred item) returns logical true. pred must be free of side-effects.
  Returns a transducer when no collection is provided."
  {:added "1.0"
   :static true}
  ;; ---- Deleted the transducer version ----
  ([pred coll]
     (lazy-seq
      (when-let [s (seq coll)]
        (when (pred (first s))
          (cons (first s) (take-while pred (rest s))))))))

(defn take-until
  [pred coll]
  (lazy-seq
    (when-let [s (seq coll)]
      (if (pred (first s))
        (cons (first s) (take-until pred (rest s)))
        (first s)))))