sritchie
commented
5 months ago I'll address these in two comments!
In the current implementation, operators can combine with non-operators ("co-operators") using +, - and *; I don't think I have the rules for this written down anywhere but I was careful to stick to the scmutils conventions and I don't think we can change them without getting into trouble mathematically.
Quick overview:
+ and -
When you add (or subtract) two operators, just like when you add two functions, you get a new operator that applies both operators and then adds (or subtracts) the two results:
emmy.env> (((+ D D) sin) 'x)
(* 2 (cos x))When you add or subtract an operator with a non-operator, the non-operator is converted to an operator that composes the non-operator with the new operator's argument. (These two are covered by combine-op-f and combine-f-op in emmy.operator, and the docstring describes what happens: https://github.com/mentat-collective/emmy/blob/main/src/emmy/operator.cljc#L229-L277)
emmy.env> (((+ D cos) sin) 'x)
(+
;; this first part is ((D sin) 'x)
(cos x)
;; the `cos` composed with `sin`, then the result applied to `x`
(cos (sin x)))*
Multiplication of two operators is the same as composition. This is important, so that ((square D) f) == (D (D f)).
Multiplication of an operator by a non-operator works differently depending on if the operator is on the left or the right.
Op on the left
If the operator is on the left, Emmy handles (* <operator> <co-operator>) by returning a new operator that does the following internally:
(fn [x]
(<operator> (* <co-operator> x)))So your (* D sin) example above becomes the operator (fn [x] (D (* sin x))), and the full example unfolds like this:
(((* D sin) 'x) 'y)
(((fn [x] (D (* sin x))) 'x) 'y)
((D (* sin 'x)) 'y)
;; remember now that (* sin 'x) is the same as `(fn [arg] (* (sin arg) ((constantly 'x) arg)))`
;; final result:
(* x (cos y))Operator on the right
If the operator is on the right, THEN things work more like what you predicted, where (* <co-operator> <operator>) becomes
(fn [x] (* <co-operator> (<operator> x)))So this would fail with flipped args, because (D 'x) is meaningless:
emmy.env> (((* sin D) 'x) 'y)
Execution error (IllegalArgumentException) at emmy.calculus.derivative/fn (derivative.cljc:459).
No method in multimethod 'partial-derivative' for dispatch value: [clojure.lang.Symbol clojure.lang.PersistentVector]
alexgian
I know that Emmy already has vector calculus functions, including div and curl, but those definitions are in a DG context, which I do not yet quite follow. It might be nice to have them wrapped in a more basic form (with sensible defaults for a conventional ℝ³ user) who may want to try out some vector calc.
However, it also occurred to me as I was thinking about it, that the definition of curl, ∇✕ , could be made to match the common textbook one fairly easily:
This could be implemented by Emmy, if a couple of small changes were made.
First, redefine multiplication of an operator by a function as the application of that operator to the function. Currently it seems to work like this:
(((* D sin) 'x) 'y)is interpreted as(* 'x ((D sin) 'y))i.e(* 'x (cos 'y))semantics which aren't clear to me, but certainly do follow the behaviour of scmutils Personally, I'd have thought that(* D sin)would be equivalent to(D sin), i.e. a simple application. Of course, there may be some important reasons that it is the way it is, but I can't see them. If anyone can explain....Secondly, we'd also need to define multiplication of a tuple of reals by a function as the scaling of that function into the tuple, i.e.
(* (up 0 1 2) sin)=>(up 0 sin (* 2 sin))At the moment this is not a case that's catered for, but I think it might make sense. With these two small changes the common determinant definition of curl is quite feasible. Just musing...