Encoding

Say you want to encode a unit as json. Given (meters 10), one reasonable representation is:

[10 , "m"]

another would be:

{
  "amount": 10,
  "unit": "m"
}

to do this you have to write something like:

(require '[anteo.units :as un])
(def m (un/meters 10))

[(un/num m) (anteo.units.impl/->symbol m)]

I think this is useful enought that anteo.units.impl/->symbol should be part of the public API.

Decoding

Say you receive the above json representation and want to construct a unit. Currently there is no good way to do this dynamically. As far as I can tell the only way to construct a meters unit is through the meters construct. So you would need to make a mapping somewhere:

{ "m" meters,
  "kg" kilograms,
  ,,,,; etc
}

I propose we create a constructor that creates a unit given an amount and its symbol. Something like:

(unit 10 "m")

would be equivalent to (meters 10) given that "m" is a registered symbol.

I propose we rename the current unit function to register-unit! and add a unit function as described above. unit doesn't currently have a two element arity so we could just add this to the existing function, but this might make the function confusing.

Cljdoc needs a commit tag matching the version on clojars to fetch source code.

See: https://cljdoc.org/builds/70245

This looks like a great library to help me with a project I need to complete.

I was wondering how you would represent a conversion between two units with differing zero points (e.g. Celsius to Fahrenheit) using this library?

Also, if a UOM conversion involves some lookup value to be used (e.g. going from volume to mass requires knowing the density of the liquid) is there a suggested approach for doing this.

I have a safe-divide function returning ##Inf when dividing by zero.

(defn safe-divide [a b]
  (if (zero? b)
    (if (neg? a)
      ##-Inf
      ##Inf)
    (/ a b)))

I'd like to have a version working with broch, but boxed-arithmetic only accepts a few functions from clojure.core.
I understand the logic behind that, but unfortunately writing my own custom boxed-arithmetic turns out to be quite difficult as most of the used functions are private.

Would it be possible to expose those functions?

Alternatively, perhaps boxed-arithmetic could expose two sub-functions where the user could do the dispatch manually?
Something like boxed-mult-div and boxed-add-sub-min-max.

nil quanities (like #broch/quantity[nil "m"]) should behave as if it's nil when used with broch fns.

For example conversion between units:

(b/nautical-miles (b/meters nil))

should yield #broch/quantity[nil "NM"], but now it throws an error.

Hi, thanks for this useful library. However, there is one common problem with JS, precision.

CLJ environment:
(b/+ (b/millimeters 1) (b/meters 1)) => #broch/quantity[1001 "mm"]
(b/* (b/+ (b/millimeters 1) (-> (b/meters 1) (b/millimeters))) (b/meters 1.5)) => #broch/quantity[1501500 "mm²"]

CLJS environment
(b/+ (b/millimeters 1) (b/meters 1)) => #broch/quantity[1000.9999999999999 "mm"]
(b/* (b/+ (b/millimeters 1) (-> (b/meters 1) (b/millimeters))) (b/meters 1.5)) => #broch/quantity[1501499.9999999998 "mm²"]

e.g. https://mathjs.org/ doesn't have this problem.

I don't know what must be done to make this more consistent with JVM results. Maybe somebody thought about this already?

As of no.anteo/broch {:mvn/version "0.1.83"}, evaluating this expression:

(do
  (require '[broch.core :as b])
  (b/* (b/seconds 1) (b/seconds 1)))

Gives me an error:

1. Unhandled clojure.lang.ExceptionInfo
   No unit is registered for {:broch/scaled 1, :time 2}
   {:broch/scaled 1, :time 2}

What are your thoughts on currently unsupported units? Are you planning to stick to a selection of common units?

My existing code doesn't work in CLJS after updating from "2023.12.15" to "2024.02.27".
b/to-edn doesn't recognize unit symbols properly.

Hi,
I can't load this library anymore, when I try it then i get:

Syntax error (ClassNotFoundException) compiling at (broch/numbers.cljc:170:4).
cljs.compiler

it seems to be caused by this:

Hi, I had to implement some functions, but unfortunately SQRT relies on the internal API.
What do you think about making them part of broch.core?

(defn pow [a b]
  (reduce b/* (repeat b a)))

(defn derive-sqrt-comp [x]
  (->> x
       b/composition
       (map (fn [[k v]] (if (= :broch/scaled k) 
                                     [k #?(:clj (rationalize (math/sqrt v))
                                         :cljs (math/sqrt v))] 
                                     [k (/ v 2)])))
       (into {})))
       
(defn sqrt [x]
  (let [result (math/sqrt (b/num x))
        composition (derive-sqrt-comp x)
        new-unit (get @broch.impl/composition-registry composition)]
    (when new-unit
      (broch.impl/quantity new-unit result))))

This looks like a great library to help me with a project I need to complete.

If a UOM conversion involves some lookup value to be used (e.g. going from volume to mass requires knowing the density of the liquid) is there a suggested approach for doing this?

Hi!

My clojure-lsp setup doesn't seem to be able to find the definition for broch.core/meters (and more) variables.

broch.core/meters works perfectly in the REPL. And broch.core/meters looks like a normal def, so I'd expect this to just work.

This is what I'm seeing, lint error for broch.core/meters and no completion for meters (but completion for other symbols!).

Broch version:

        no.anteo/broch {:mvn/version "0.1.83"}

Screenshots were produced with this LSP+clj-kondo version:

 :server-version "2023.08.06-00.33.37-nightly",
 :clj-kondo-version "2023.07.14-SNAPSHOT",

(up-to-date versions provided by Doom Emacs (clojure +lsp) as of 2023-10-19).

For all that I can see, this is more likely to indicate an issue in Clojure-LSP than broch. But I thought I'd ask if you guys have any ideas first -- because you know the broch codebase.

I think it's weird that some vars (like b/* og b/max) were found without issues, whereas other vars (like b/meters) were not found. Perhaps a first step is to try reproduce the issue.

Teodor

Numbers are sometimes converted to ratios on unit construction. Like this

(b/meters 301873.55787421204) 
; => #broch/unit[7546838946855301/25000000000 "m"]