(DEFINE-CIRCUIT WEIGHTED-COMBINATION
                (:INPUTS X Y)
                (:OUTPUTS OUTPUT)
                (:REGISTER-INIT Y-WEIGHT Y-INIT-WEIGHT)
                (:REGISTER-INIT X-WEIGHT X-INIT-WEIGHT)
                (:COMPONENT +-0 OUTPUT (+ W-147 W-148))
                (:COMPONENT *-1 W-148 (* Y-WEIGHT Y))
                (:COMPONENT *-0 W-147 (* X-WEIGHT X)))
(DEFINE-CIRCUIT FILTER-DEMO
                (:INPUTS FAST-CLOCK SLOW-CLOCK)
                (:OUTPUTS OUT1 OUT2)
                (:COMPONENT LOW-PASS-3
                            OUT2
                            (LOW-PASS FAST-CLOCK W-58))
                (:COMPONENT LOW-PASS-2
                            OUT1
                            (LOW-PASS FAST-CLOCK W-57))
                (:COMPONENT SIN-WAVE-1
                            W-58
                            (SIN-WAVE SLOW-CLOCK))
                (:COMPONENT SIN-WAVE-0
                            W-57
                            (SIN-WAVE FAST-CLOCK)))
(DEFINE-CIRCUIT WEIGHTED-COMBINATION
                (:INPUTS X Y)
                (:OUTPUTS OUTPUT)
                (:REGISTER-INIT Y-WEIGHT Y-INIT-WEIGHT)
                (:REGISTER-INIT X-WEIGHT X-INIT-WEIGHT)
                (:COMPONENT +-0 OUTPUT (+ W-147 W-148))
                (:COMPONENT *-1 W-148 (* Y-WEIGHT Y))
                (:COMPONENT *-0 W-147 (* X-WEIGHT X)))
(DEFINE-CIRCUIT WEIGHTED-COMBINATION
                (:INPUTS X Y)
                (:OUTPUTS OUTPUT)
                (:REGISTER-INIT Y-WEIGHT Y-INIT-WEIGHT)
                (:REGISTER-INIT X-WEIGHT X-INIT-WEIGHT)
                (:COMPONENT +-0 OUTPUT (+ W-147 W-148))
                (:COMPONENT *-1 W-148 (* Y-WEIGHT Y))
                (:COMPONENT *-0 W-147 (* X-WEIGHT X)))
(DEFINE-CIRCUIT TWO-CLOCKS
                (:INPUTS CLOCK1 CLOCK2)
                (:OUTPUTS OUTPUT1 OUTPUT2)
                (:REGISTER-INIT OUTPUT2 0)
                (:REGISTER-INIT OUTPUT1 0)
                (:REGISTER-INIT COUNTER2 0)
                (:REGISTER-INIT COUNTER1 0)
                (:REGISTER-INIT ONE 1)
                (:COMPONENT PLUS-2
                            COUNTER2-INC
                            (+ ONE COUNTER2))
                (:COMPONENT PLUS-1
                            COUNTER1-INC
                            (+ ONE COUNTER1))
                (:REGISTER-INPUT OUTPUT2 COUNTER2 CLOCK2)
                (:REGISTER-INPUT OUTPUT1 COUNTER1 CLOCK1)
                (:REGISTER-INPUT COUNTER2 COUNTER2-INC CLOCK2)
                (:REGISTER-INPUT COUNTER1 COUNTER1-INC CLOCK1))
(DEFINE-CIRCUIT SIMPLE-NAV
                (:INPUTS BASIC-CLOCK)
                (:OUTPUTS POSITION INU-VEL)
                (:COMPONENT GPS-DEVICE-1
                            GPS-POS
                            (GPS-DEVICE BASIC-CLOCK))
                (:COMPONENT INU-DEVICE-1
                            INU-POS
                            INU-VEL
                            (INU-DEVICE BASIC-CLOCK))
                (:COMPONENT 3-VECTOR-COMPLEMENTARY-FILTER-1
                            POSITION
                            (3-VECTOR-COMPLEMENTARY-FILTER BASIC-CLOCK
                                                           INU-POS
                                                           GPS-POS)))
(DEFINE-CIRCUIT 3-VECTOR-COMPLEMENTARY-FILTER
                (:INPUTS CLOCK-INPUT S1 S2)
                (:OUTPUTS COMBINATION)
                (:REGISTER-INIT PREVIOUS 3-VECTOR-0)
                (:COMPONENT 3-VECTOR-DIFFERENCE-FROM-PREVIOUS-1
                            DELTA-S1
                            (3-VECTOR-DIFFERENCE-FROM-PREVIOUS CLOCK-INPUT S1))
                (:COMPONENT 3D-SUM-1
                            NEW-S1-ESTIMATE
                            (3D-SUM PREVIOUS DELTA-S1))
                (:COMPONENT 3D-WEIGHTED-COMBINATION-1
                            COMBINATION
                            (3D-WEIGHTED-COMBINATION S2 NEW-S1-ESTIMATE))
                (:REGISTER-INPUT PREVIOUS COMBINATION CLOCK-INPUT))
(DEFINE-CIRCUIT 3-VECTOR-DIFFERENCE-FROM-PREVIOUS
                (:INPUTS CLOCK VAL)
                (:OUTPUTS DIFF)
                (:REGISTER-INIT PREVIOUS-VAL 3-VECTOR-0)
                (:COMPONENT 3D-DIFFERENCE-1
                            DIFF
                            (3D-DIFFERENCE VAL PREVIOUS-VAL))
                (:REGISTER-INPUT PREVIOUS-VAL VAL CLOCK))
(DEFINE-CIRCUIT 3D-WEIGHTED-COMBINATION
                (:INPUTS X Y)
                (:OUTPUTS OUTPUT)
                (:REGISTER-INIT Y-WEIGHT Y-INIT-WEIGHT)
                (:REGISTER-INIT X-WEIGHT X-INIT-WEIGHT)
                (:COMPONENT 3D-SCALAR-MULT-2
                            Y-PART
                            (3D-SCALAR-MULT Y-WEIGHT Y))
                (:COMPONENT 3D-SCALAR-MULT-1
                            X-PART
                            (3D-SCALAR-MULT X-WEIGHT X))
                (:COMPONENT 3D-SUM-1
                            OUTPUT
                            (3D-SUM X-PART Y-PART)))
(DEFINE-CIRCUIT 3D-SCALAR-MULT
                (:INPUTS M Y)
                (:OUTPUTS OUTPUT)
                (:COMPONENT 3-VECTOR-Z-1
                            Y3
                            (3-VECTOR-Z Y))
                (:COMPONENT 3-VECTOR-Y-1
                            Y2
                            (3-VECTOR-Y Y))
                (:COMPONENT 3-VECTOR-X-1
                            Y1
                            (3-VECTOR-X Y))
                (:COMPONENT *3 Z3 (* M Y3))
                (:COMPONENT *2 Z2 (* M Y2))
                (:COMPONENT *1 Z1 (* M Y1))
                (:COMPONENT MAKE-3-VECTOR-1
                            OUTPUT
                            (MAKE-3-VECTOR Z1 Z2 Z3)))
(DEFINE-CIRCUIT 3D-SUM
                (:INPUTS X Y)
                (:OUTPUTS SUM)
                (:COMPONENT 3-VECTOR-Z-2
                            Y3
                            (3-VECTOR-Z Y))
                (:COMPONENT 3-VECTOR-Y-2
                            Y2
                            (3-VECTOR-Y Y))
                (:COMPONENT 3-VECTOR-X-2
                            Y1
                            (3-VECTOR-X Y))
                (:COMPONENT 3-VECTOR-Z-1
                            X3
                            (3-VECTOR-Z X))
                (:COMPONENT 3-VECTOR-Y-1
                            X2
                            (3-VECTOR-Y X))
                (:COMPONENT 3-VECTOR-X-1
                            X1
                            (3-VECTOR-X X))
                (:COMPONENT PLUS-3 Z3 (+ X3 Y3))
                (:COMPONENT PLUS-2 Z2 (+ X2 Y2))
                (:COMPONENT PLUS-1 Z1 (+ X1 Y1))
                (:COMPONENT MAKE-3-VECTOR-1
                            SUM
                            (MAKE-3-VECTOR Z1 Z2 Z3)))
(DEFINE-CIRCUIT 3D-DIFFERENCE
                (:INPUTS X Y)
                (:OUTPUTS DIFF)
                (:COMPONENT 3-VECTOR-Z-2
                            Y3
                            (3-VECTOR-Z Y))
                (:COMPONENT 3-VECTOR-Y-2
                            Y2
                            (3-VECTOR-Y Y))
                (:COMPONENT 3-VECTOR-X-2
                            Y1
                            (3-VECTOR-X Y))
                (:COMPONENT 3-VECTOR-Z-1
                            X3
                            (3-VECTOR-Z X))
                (:COMPONENT 3-VECTOR-Y-1
                            X2
                            (3-VECTOR-Y X))
                (:COMPONENT 3-VECTOR-X-1
                            X1
                            (3-VECTOR-X X))
                (:COMPONENT MINUS-3 Z3 (- X3 Y3))
                (:COMPONENT MINUS-2 Z2 (- X2 Y2))
                (:COMPONENT MINUS-1 Z1 (- X1 Y1))
                (:COMPONENT MAKE-3-VECTOR-1
                            DIFF
                            (MAKE-3-VECTOR Z1 Z2 Z3)))