Fix series freeze impl (#166)

Author: sritchie

src/emmy/series.cljc

@@ -870,16 +870,18 @@
 (defmethod g/exact? [::series] [_] false)
 (defmethod g/exact? [::power-series] [_] false)
 (defmethod g/freeze [::power-series] [^PowerSeries s]
-        (let [prefix (->> (g/simplify (take 4 (.-xs s)))
-                          (g/freeze)
-                          (filter (complement g/zero?))
-                          (map-indexed
-                           (fn [n a]
-                             (if (g/one? a)
-                               `(~'expt ~'_ ~n)
-                               `(~'* ~a (~'expt ~'_ ~n))))))]
-          `(~'+ ~@prefix ~'...)))
+  (let [prefix (->> (g/simplify (take 4 (.-xs s)))
+                    (g/freeze)
+                    (into [] (comp
+                              (map-indexed
+                               (fn [n a]
+                                 (cond (g/zero? a) []
+                                       (g/one? a)  [(list 'expt '_ n)]
+                                       :else       [(list '* a (list 'expt '_ n))])))
+                              cat)))]
+    `(~'+ ~@prefix ~'...)))
+
 (defmethod g/freeze [::series] [^Series s]
-        (let [prefix (g/freeze
-                      (g/simplify (take 4 (.-xs s))))]
-          `(~'+ ~@prefix ~'...)))
+  (let [prefix (g/freeze
+                (g/simplify (take 4 (.-xs s))))]
+    `(~'+ ~@prefix ~'...)))

test/emmy/series_test.cljc

@@ -286,7 +286,17 @@
         (is (= "(+ (* 4 (expt _ 0)) (* 5 (expt _ 1)) (* 6 (expt _ 2)) (* 7 (expt _ 3)) ...)"
                (str p)))
         (is (= (str s) (str (g/freeze s))))
-        (is (= (str p) (str (g/freeze p))))))))
+        (is (= (str p) (str (g/freeze p))))
+
+        (is (= "(+ (expt _ 0) (* (/ -1 2) (expt _ 2)) ...)"
+               (str
+                (g/freeze s/cos-series)))
+            "cosine representation has the initial 1, drops correct zeros")
+
+        (is (= "(+ (expt _ 1) (* (/ -1 6) (expt _ 3)) ...)"
+               (str
+                (g/freeze s/sin-series)))
+            "sine representation drops correct zeros")))))
 
 (deftest series-as-fn-tests
   (let [f (fn [i] #(g/* %1 %2 i))