(def a1 [-1 0 -1 -1 -2])
(def a2 [1 1 1 0 1])
(def a3 [-1 2 -2 -4 -5])
(def xG [1 2 3 1 2])
;(def a1 [1 -2 1 3 0])
;(def a2 [2 -1 0 2 -1])
;(def a3 [1 0 -1 2 0])
;(def xG [1 3 -2 1 1])
(defn vAny [f]
  (fn [vect1, vect2]
    (mapv f vect1, vect2)))

(def v+ (vAny +))

(def v- (vAny -))

(def v* (vAny *))

(defn scalar [vect1, vect2]
  (def x 0)
  (mapv #(def x (+ x %)) (v* vect1, vect2))
  x)

(defn vect [vect1, vect2]
  (defn countScalar [i, j] (- (* (nth vect1, i) (nth vect2, j)) (* (nth vect1, j) (nth vect2, i))))
  (vector (countScalar 1, 2), (countScalar 2, 0), (countScalar 0, 1)))

(defn v*s [vect, scal] (mapv #(* %, scal) vect))

(def m+ (vAny v+))

(def m- (vAny v-))

(def m* (vAny v*))

(defn m*s [matrix, scal] (mapv #(v*s %, scal) matrix))

(defn m*v [matrix, vector] (mapv #(scalar % vector) matrix))

(defn transpose [matrix] (apply mapv vector matrix));

(defn m*m [matrix1, matrix2] (transpose (mapv #(m*v matrix1 %) (transpose matrix2))))

(defn sAny
  [oper]
  (fn localFunc [a, b]
    (if (number? a) (oper a b) (mapv localFunc a b))))

(def s+ (sAny +))

(def s- (sAny -))

(def s* (sAny *))

(def e1 a1)
(def e1Norm (/(scalar e1 e1)))
(println "e1 = sqrt("e1Norm ")* " e1 )
(def e1' (v*s e1 ( *(scalar e1 a2) (/ (scalar e1 e1)))))
(def e2 (v- a2 e1'))
(def e2Norm (/(scalar e2 e2)))
(println "e2 = sqrt("e2Norm ")* " e2 )
(def e1'' (v*s (v*s e1 (scalar e1 a3)) (/ (scalar e1 e1))))
(def e2' (v*s (v*s e2 (scalar e2 a3)) e2Norm))
(def e3 (v- (v- a3 e2') e1''))
(def e3Norm (/(scalar e3 e3)))
(println "e3 = sqrt("e3Norm ")* " e3 )
(def xL (v+ (v+ (v*s e1 (* (scalar xG e1) e1Norm)) (v*s e2  (* (scalar xG e2) e2Norm))) (v*s e3 (* (scalar xG e3) e3Norm))))
(println "xL = " xL)
(println "xM =" (v- xG xL))