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

SCM Repository

[diderot] View of /branches/vis12/src/compiler/simplify/simple-types.sml
ViewVC logotype

View of /branches/vis12/src/compiler/simplify/simple-types.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3291 - (download) (annotate)
Wed Oct 14 21:25:00 2015 UTC (4 years ago) by jhr
File size: 4447 byte(s)
code is copyright University of Chicago
(* simple-types.sml
 *
 * This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu)
 *
 * COPYRIGHT (c) 2015 The University of Chicago
 * All rights reserved.
 *
 * Internal representation of Diderot types after simplification.  This is essentially
 * the Types representations with the meta variables stripped out.
 *)

structure SimpleTypes =
  struct

    datatype ty
      = T_Bool
      | T_Int
      | T_String
      | T_Sequence of ty * dim  (* fixed-sized sequence of values *)
      | T_DynSequence of ty     (* dynamically sized sequence of values *)
    (* convolution kernel; argument is number of levels of differentiation *)
      | T_Kernel of diff
    (* scalars, vectors, matrices, etc.; argument is tensor shape *)
      | T_Tensor of shape
    (* data sets from NRRD *)
      | T_Image of {
          dim : dim,            (* 1D, 2D, or 3D data set *)
          shape : shape         (* tensor shape; order is length of list *)
        }
    (* continuous field reconstructed from a data set *)
      | T_Field of {
          diff : diff,          (* number of levels of differentiation supported *)
          dim : dim,            (* dimension of domain (2D or 3D field) *)
          shape : shape         (* shape of tensors in range; order is length of list *)
        }
      | T_Fun of ty list * ty

    withtype diff = int
         and shape = int list
         and dim = int

  (* instantiated meta variable values *)
    datatype meta_arg
      = TY of ty
      | DIFF of diff
      | SHAPE of shape
      | DIM of dim

    local
      fun listToString fmt sep items = String.concatWith sep (List.map fmt items)
      val shapeToString = listToString Int.toString ","
    in
    fun toString ty = (case ty
           of T_Bool => "bool"
            | T_Int => "int"
            | T_String => "string"
            | T_Sequence(ty, dim) => concat[toString ty, "{", Int.toString dim, "}"]
            | T_DynSequence ty => toString ty ^ "{}"
            | T_Kernel n => "kernel#" ^ Int.toString n
            | T_Tensor[] => "real"
            | T_Tensor[2] => "vec2"
            | T_Tensor[3] => "vec3"
            | T_Tensor[4] => "vec4"
            | T_Tensor shape => concat["tensor[", shapeToString shape, "]"]
            | T_Image{dim, shape} => concat[
                  "image(", Int.toString dim, ")[", shapeToString shape, "]"
                ]
            | T_Field{diff, dim, shape} => concat[
                  "field#", Int.toString diff, "(", Int.toString dim,
                  ")[", shapeToString shape, "]"
                ]
            | T_Fun(tys1, ty2) => let
                fun tysToString [] = "()"
                  | tysToString [ty] = toString ty
                  | tysToString tys = String.concat[
                        "(", listToString toString " * " tys, ")"
                      ]
                in
                  String.concat[tysToString tys1, " -> ", toString ty2]
                end
          (* end case *))
    end (* local *)

  (* return the range (return type) of a function type *)
    fun rngOf (T_Fun(_, ty)) = ty
      | rngOf ty = raise Fail(concat["SimpleTypes.rngOf(", toString ty, ")"])

    local
      structure Ty = Types
      structure TU = TypeUtil
    (* convert to fully resolved monomorphic forms *)
    in
  (* convert a Types.ty to a SimpleTypes.ty *)
    fun simplify ty = (case ty
           of Ty.T_Var(Ty.TV{bind, ...}) => (case !bind
                 of NONE => raise Fail "unresolved type variable"
                  | SOME ty => simplify ty
                (* end case *))
            | Ty.T_Bool => T_Bool
            | Ty.T_Int => T_Int
            | Ty.T_String => T_String
            | Ty.T_Sequence(ty, dim) => T_Sequence(simplify ty, TU.monoDim dim)
            | Ty.T_DynSequence ty => T_DynSequence(simplify ty)
            | Ty.T_Kernel n => T_Kernel(TU.monoDiff n)
            | Ty.T_Tensor shape => T_Tensor(TU.monoShape shape)
            | Ty.T_Image{dim, shape} => T_Image{
                  dim = TU.monoDim dim,
                  shape = TU.monoShape shape
                }
            | Ty.T_Field{diff, dim, shape} => T_Field{
                  diff = TU.monoDiff diff,
                  dim = TU.monoDim dim,
                  shape = TU.monoShape shape
                }
            | Ty.T_Fun(tys1, ty2) => T_Fun(List.map simplify tys1, simplify ty2)
          (* end case *))
    end
      
  end

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