Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] View of /branches/charisee/src/compiler/high-to-mid/Transform.sml
ViewVC logotype

View of /branches/charisee/src/compiler/high-to-mid/Transform.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3066 - (download) (annotate)
Sat Mar 14 16:34:25 2015 UTC (4 years, 5 months ago) by cchiw
File size: 4339 byte(s)
load->image, det(), S*T
(* 
 *This file does world to image space Transformations
 * Take a look at tex file for examples
 * COPYRIGHT (c) 2012 The Diderot Project (http://diderot-language.cs.uchicago.edu)
 * All rights reserved.
 *)



structure TransformEin = struct

    local
   
    structure E = Ein
    structure DstIL = MidIL
    structure DstTy = MidILTypes
    structure DstOp = MidOps
    structure DstV = DstIL.Var
    structure P = Printer
    structure Mk = MkOperators

in
    val testing=0
    fun assign (x, rator, args) = (x, DstIL.OP(rator, args))
    fun assignEin (x, rator, args) = ((x, DstIL.EINAPP(rator, args)))
    fun testp n=(case testing
        of 0=> 1
        | _ =>(print(String.concat n);1)
        (*end case*))
    val cnt = ref 0
    fun genName prefix = let
        val n = !cnt
        in
            cnt := n+1;
            String.concat[prefix, "_", Int.toString n]
        end

    (*getTys:int->ty*int list *int list
    *Returns types based on field dimension
    * Really, just done literally so that 1-d fields pass the type-checker
    *)
    fun getTys 1= (DstTy.intTy,[],[])
    | getTys dim = (DstTy.iVecTy dim,[dim],[dim,dim])

    (* WorldToImagespace:dim* imageinfo* mid-il var* mid-il var
        ->mid-il var * mid-il var *code
    *transform image-space position x to world space position
    *)
    fun WorldToImagespace(dim,v,posx,imgArgDst)=let
        val translate=DstOp.Translate v
        val transform=DstOp.Transform v
        val (_ ,fty,pty)=getTys dim
        val mty=DstTy.TensorTy  pty
        val rty=DstTy.TensorTy fty
        val M  = DstV.new (genName "M", mty)   (*transform dim by dim?*)
        val T  = DstV.new (genName "T", rty)
        val x  = DstV.new (genName "x", rty)            (*Image-Space position*)
        val x0  = DstV.new (genName "x0", rty)
        val (PosToImgSpaceA,PosToImgSpaceB)=(case dim
            of 1=>(Mk.mulRR,Mk.addRR)
            | _ => (Mk.innerTT([dim,dim],[dim]), Mk.addTT[dim])
            (*end case*))
        val code=[
            assign(M, transform, [imgArgDst]),
            assign(T, translate, [imgArgDst]),
            assignEin(x0, PosToImgSpaceA,[M,posx]) , (*xo=MX*)
            assignEin(x, PosToImgSpaceB,[x0,T])  (*x=x0+T*)
        ]
        in
            (M,x,code)
        end

    (*transformToImgSpae:int*imginfo*mid-ilvar*mid-ilvar
        -> mid_il var list * mid-il var* code
    *Create fractional, and integer position vectors
    *)
    fun transformToImgSpace  (dim,v,posx,imgArgDst)=let
        val (ity,fty,pty)=getTys dim
        val mty=DstTy.TensorTy  pty
        val rty=DstTy.TensorTy fty
        val f  = DstV.new ("f", rty)            (*fractional*)
        val nd = DstV.new ("nd",  rty)           (*real position*)
        val n  = DstV.new ("n", ity)           (*integer position*)
        val P  = DstV.new ("P",mty)   (*transform dim by dim?*)
        val (M,x,code1)=WorldToImagespace(dim,v,posx,imgArgDst)
        val (P,PCode)=(case dim
            of 1=>(M,[])
            | _ =>(P,[assignEin(P, Mk.transposeT(pty), [M])])
            (*end case*))
        val code=[
            assign(nd, DstOp.Floor dim, [x]),   (*nd *)
            assignEin(f, Mk.subTT(fty),[x,nd]),           (*fractional*)
            assign(n, DstOp.RealToInt dim, [nd]) (*real to Int*)
        ]
        in
            ([n,f],P,code1@PCode@code)
        end

    (*transformToIndexSpace:int*int*mu list * param_id
    *Make Transform Matrices, and returns new indices as mu and sum_indexids
    *)
    fun transformToIndexSpace(freshIndex,dim,dx,Pid)=let
        fun iter([],_,newdx,newsx,Ps)=(newdx,newsx,Ps)
        | iter (i::es,n,newdx,newsx,Ps)=(case i
            of E.V v=>  let
                val j=E.V n
                val s=(j,0,dim-1)
                val P=E.Tensor(Pid,[i,j])
                in
                    iter (es,n+1,newdx@[j],newsx@[s],Ps@[P])
                end
            | E.C c=> let
                val j=E.V n
                val s=(j,0,dim-1)
                val P=E.Tensor(Pid,[i,j])
                in
                    iter (es,n+1,newdx@[j],newsx@[s],Ps@[P])
                end
            (*raise Fail"Unsure how to Transform constant differentiation"*)
        (*end case*))
    val (newdx,newsx,Ps)= iter(dx,freshIndex,[],[],[])
    in
        (newdx,newsx,Ps)
    end




end
end

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0