cannam@167: (*
cannam@167:  * Copyright (c) 1997-1999 Massachusetts Institute of Technology
cannam@167:  * Copyright (c) 2003, 2007-14 Matteo Frigo
cannam@167:  * Copyright (c) 2003, 2007-14 Massachusetts Institute of Technology
cannam@167:  *
cannam@167:  * This program is free software; you can redistribute it and/or modify
cannam@167:  * it under the terms of the GNU General Public License as published by
cannam@167:  * the Free Software Foundation; either version 2 of the License, or
cannam@167:  * (at your option) any later version.
cannam@167:  *
cannam@167:  * This program is distributed in the hope that it will be useful,
cannam@167:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
cannam@167:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
cannam@167:  * GNU General Public License for more details.
cannam@167:  *
cannam@167:  * You should have received a copy of the GNU General Public License
cannam@167:  * along with this program; if not, write to the Free Software
cannam@167:  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
cannam@167:  *
cannam@167:  *)
cannam@167: 
cannam@167: (* abstraction layer for complex operations *)
cannam@167: open Littlesimp
cannam@167: open Expr
cannam@167: 
cannam@167: (* type of complex expressions *)
cannam@167: type expr = CE of Expr.expr * Expr.expr
cannam@167: 
cannam@167: let two = CE (makeNum Number.two, makeNum Number.zero)
cannam@167: let one = CE (makeNum Number.one, makeNum Number.zero)
cannam@167: let i = CE (makeNum Number.zero, makeNum Number.one)
cannam@167: let zero = CE (makeNum Number.zero, makeNum Number.zero)
cannam@167: let make (r, i) = CE (r, i)
cannam@167: 
cannam@167: let uminus (CE (a, b)) =  CE (makeUminus a, makeUminus b)
cannam@167: 
cannam@167: let inverse_int n = CE (makeNum (Number.div Number.one (Number.of_int n)),
cannam@167: 			makeNum Number.zero)
cannam@167: 
cannam@167: let inverse_int_sqrt n = 
cannam@167:   CE (makeNum (Number.div Number.one (Number.sqrt (Number.of_int n))),
cannam@167:       makeNum Number.zero)
cannam@167: let int_sqrt n = 
cannam@167:   CE (makeNum (Number.sqrt (Number.of_int n)),
cannam@167:       makeNum Number.zero)
cannam@167: 
cannam@167: let nan x = CE (NaN x, makeNum Number.zero)
cannam@167: 
cannam@167: let half = inverse_int 2
cannam@167: 
cannam@167: let times3x3 (CE (a, b)) (CE (c, d)) = 
cannam@167:   CE (makePlus [makeTimes (c, makePlus [a; makeUminus (b)]);
cannam@167: 	        makeTimes (b, makePlus [c; makeUminus (d)])],
cannam@167:       makePlus [makeTimes (a, makePlus [c; d]);
cannam@167: 	        makeUminus(makeTimes (c, makePlus [a; makeUminus (b)]))])
cannam@167: 
cannam@167: let times (CE (a, b)) (CE (c, d)) = 
cannam@167:   if not !Magic.threemult then
cannam@167:     CE (makePlus [makeTimes (a, c); makeUminus (makeTimes (b, d))],
cannam@167:         makePlus [makeTimes (a, d); makeTimes (b, c)])
cannam@167:   else if is_constant c && is_constant d then
cannam@167:     times3x3 (CE (a, b)) (CE (c, d))
cannam@167:   else (* hope a and b are constant expressions *)
cannam@167:     times3x3 (CE (c, d)) (CE (a, b))
cannam@167: 
cannam@167: let ctimes (CE (a, _)) (CE (c, _)) = 
cannam@167:   CE (CTimes (a, c), makeNum Number.zero)
cannam@167: 
cannam@167: let ctimesj (CE (a, _)) (CE (c, _)) = 
cannam@167:   CE (CTimesJ (a, c), makeNum Number.zero)
cannam@167:       
cannam@167: (* complex exponential (of root of unity); returns exp(2*pi*i/n * m) *)
cannam@167: let exp n i =
cannam@167:   let (c, s) = Number.cexp n i
cannam@167:   in CE (makeNum c, makeNum s)
cannam@167: 
cannam@167: (* various trig functions evaluated at (2*pi*i/n * m) *)
cannam@167: let sec n m =
cannam@167:   let (c, s) = Number.cexp n m
cannam@167:   in CE (makeNum (Number.div Number.one c), makeNum Number.zero)
cannam@167: let csc n m =
cannam@167:   let (c, s) = Number.cexp n m
cannam@167:   in CE (makeNum (Number.div Number.one s), makeNum Number.zero)
cannam@167: let tan n m =
cannam@167:   let (c, s) = Number.cexp n m
cannam@167:   in CE (makeNum (Number.div s c), makeNum Number.zero)
cannam@167: let cot n m =
cannam@167:   let (c, s) = Number.cexp n m
cannam@167:   in CE (makeNum (Number.div c s), makeNum Number.zero)
cannam@167:     
cannam@167: (* complex sum *)
cannam@167: let plus a =
cannam@167:   let rec unzip_complex = function
cannam@167:       [] -> ([], [])
cannam@167:     | ((CE (a, b)) :: s) ->
cannam@167:         let (r,i) = unzip_complex s
cannam@167: 	in
cannam@167: 	(a::r), (b::i) in
cannam@167:   let (c, d) = unzip_complex a in
cannam@167:   CE (makePlus c, makePlus d)
cannam@167: 
cannam@167: (* extract real/imaginary *)
cannam@167: let real (CE (a, b)) = CE (a, makeNum Number.zero)
cannam@167: let imag (CE (a, b)) = CE (b, makeNum Number.zero)
cannam@167: let iimag (CE (a, b)) = CE (makeNum Number.zero, b)
cannam@167: let conj (CE (a, b)) = CE (a, makeUminus b)
cannam@167: 
cannam@167:     
cannam@167: (* abstraction of sum_{i=0}^{n-1} *)
cannam@167: let sigma a b f = plus (List.map f (Util.interval a b))
cannam@167: 
cannam@167: (* store and assignment operations *)
cannam@167: let store_real v (CE (a, b)) = Expr.Store (v, a)
cannam@167: let store_imag v (CE (a, b)) = Expr.Store (v, b)
cannam@167: let store (vr, vi) x = (store_real vr x, store_imag vi x)
cannam@167: 
cannam@167: let assign_real v (CE (a, b)) = Expr.Assign (v, a)
cannam@167: let assign_imag v (CE (a, b)) = Expr.Assign (v, b)
cannam@167: let assign (vr, vi) x = (assign_real vr x, assign_imag vi x)
cannam@167: 
cannam@167: 
cannam@167: (************************
cannam@167:    shortcuts 
cannam@167:  ************************)
cannam@167: let (@*) = times
cannam@167: let (@+) a b = plus [a; b]
cannam@167: let (@-) a b = plus [a; uminus b]
cannam@167: 
cannam@167: (* type of complex signals *)
cannam@167: type signal = int -> expr
cannam@167: 
cannam@167: (* make a finite signal infinite *)
cannam@167: let infinite n signal i = if ((0 <= i) && (i < n)) then signal i else zero
cannam@167: 
cannam@167: let hermitian n a =
cannam@167:   Util.array n (fun i ->
cannam@167:     if (i = 0) then real (a 0)
cannam@167:     else if (i < n - i)  then (a i)
cannam@167:     else if (i > n - i)  then conj (a (n - i))
cannam@167:     else real (a i))
cannam@167: 
cannam@167: let antihermitian n a =
cannam@167:   Util.array n (fun i ->
cannam@167:     if (i = 0) then iimag (a 0)
cannam@167:     else if (i < n - i)  then (a i)
cannam@167:     else if (i > n - i)  then uminus (conj (a (n - i)))
cannam@167:     else iimag (a i))