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

SCM Repository

[diderot] Diff of /branches/vis15/src/compiler/ein/mk-operators.sml
ViewVC logotype

Diff of /branches/vis15/src/compiler/ein/mk-operators.sml

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3478, Thu Dec 3 17:26:24 2015 UTC revision 3978, Wed Jun 15 19:07:40 2016 UTC
# Line 46  Line 46 
46      val cross2FF : Ein.ein      val cross2FF : Ein.ein
47      val cross3FF : Ein.ein      val cross3FF : Ein.ein
48    
49  (* QUESTION: why not just "outerTT : shape * shape -> Ein.ein" ? *)      val outerTT : shape * shape -> Ein.ein
50      val outerTT : dim * dim -> Ein.ein      val outerFF : dim * shape * shape -> Ein.ein
51      val outerTM : dim * shape -> Ein.ein      val outerTF : dim * shape * shape -> Ein.ein
52      val outerMT : shape * dim -> Ein.ein      val outerFT : dim * shape * shape -> Ein.ein
 (* QUESTION: should these be index_kind? *)  
     val outerFF : dim * Ein.index_id * Ein.index_id -> Ein.ein  
53    
54      val innerTT : shape * ids -> Ein.ein      val innerTT : shape * ids -> Ein.ein
55      val innerFF : shape * dim * ids -> Ein.ein      val innerFF : shape * dim * ids -> Ein.ein
# Line 63  Line 61 
61      val colonFT : dim * shape * ids -> Ein.ein      val colonFT : dim * shape * ids -> Ein.ein
62      val colonTF : dim * shape * ids -> Ein.ein      val colonTF : dim * shape * ids -> Ein.ein
63    
64      val magnitudeTT : shape -> Ein.ein      val normT : shape -> Ein.ein
65      val magnitudeFF : dim * shape -> Ein.ein      val normF : dim * shape -> Ein.ein
66    
67      val normalizeTT : shape -> Ein.ein      val normalizeTT : shape -> Ein.ein
68      val normalizeFF : dim * shape -> Ein.ein      val normalizeFF : dim * shape -> Ein.ein
# Line 86  Line 84 
84      val expF : dim -> Ein.ein      val expF : dim -> Ein.ein
85      val expT : Ein.ein      val expT : Ein.ein
86    
87      val powF  : dim * int -> Ein.ein      val powFI  : dim * int -> Ein.ein
88        val sqrtR : Ein.ein
89      val sqrtF : dim -> Ein.ein      val sqrtF : dim -> Ein.ein
90        val cosR  : Ein.ein
91      val cosF  : dim -> Ein.ein      val cosF  : dim -> Ein.ein
92        val acosR : Ein.ein
93      val acosF : dim -> Ein.ein      val acosF : dim -> Ein.ein
94        val sinR  : Ein.ein
95      val sinF  : dim -> Ein.ein      val sinF  : dim -> Ein.ein
96        val asinR : Ein.ein
97      val asinF : dim -> Ein.ein      val asinF : dim -> Ein.ein
98        val tanR  : Ein.ein
99      val tanF  : dim -> Ein.ein      val tanF  : dim -> Ein.ein
100        val atanR : Ein.ein
101      val atanF : dim -> Ein.ein      val atanF : dim -> Ein.ein
102    
103      val modulate : dim -> Ein.ein      val modulate : dim -> Ein.ein
# Line 120  Line 124 
124      type shape = dim list      type shape = dim list
125      type ids = int list      type ids = int list
126    
127      (* controls whether tensor operations should be *)
128        val canSubst = true
129    
130      (* A constructor function for tensor variables that (by default) can be substituted for;
131       * this behavior is controlled by the canSubst flag.
132       *)
133        fun mkTEN alpha = E.TEN(canSubst, alpha)
134    
135      (* a constructor function for tensor parameters that should never be substituted for.  *)
136        fun mkNoSubstTEN alpha = E.TEN(false, alpha)
137    
138      fun specialize (alpha, inc) = List.mapi (fn (i, _) => E.V(i + inc)) alpha      fun specialize (alpha, inc) = List.mapi (fn (i, _) => E.V(i + inc)) alpha
139    
140      fun sumIds (n, inc, alpha) = let      fun sumIds (n, inc, alpha) = let
141          val vs = List.tabulate(n, fn v => E.V(v+inc))          val vs = List.tabulate(n, fn v => (v+inc))
142          in          in
143            ListPair.map (fn(v, i) => (v, 0, i-1)) (vs, alpha)            ListPair.map (fn(v, i) => (v, 0, i-1)) (vs, alpha)
144          end          end
145    
146      fun sumIds2 (n, i) = List.tabulate(n, fn v => (E.V v, 0, i))      fun sumIds2 (n, i) = List.tabulate(n, fn v => (v, 0, i))
   
     val subst_flag = 0 (*here*) (* ????? *)  
147    
148    (******************************* Addition *****************************************)    (******************************* Addition *****************************************)
149    
# Line 139  Line 152 
152            val expindex = specialize(alpha, 0)            val expindex = specialize(alpha, 0)
153            in            in
154              E.EIN{              E.EIN{
155                  params = [E.TEN(subst_flag, alpha), E.TEN(subst_flag, alpha)],                  params = [mkTEN alpha, mkTEN alpha],
156                  index = alpha,                  index = alpha,
157                  body = E.Opn(E.Add, [E.Tensor(0, expindex), E.Tensor(1, expindex)])                  body = E.Opn(E.Add, [E.Tensor(0, expindex), E.Tensor(1, expindex)])
158                }                }
# Line 152  Line 165 
165            val expindex = specialize(shape, 0)            val expindex = specialize(shape, 0)
166            in            in
167              E.EIN{              E.EIN{
168                  params = [E.TEN(subst_flag, shape), E.FLD dim],                  params = [mkTEN shape, E.FLD dim],
169                  index = shape,                  index = shape,
170                  body = E.Opn(E.Add, [E.Lift(E.Tensor(0, expindex)), E.Field(1, expindex)])                  body = E.Opn(E.Add, [E.Lift(E.Tensor(0, expindex)), E.Field(1, expindex)])
171                }                }
# Line 175  Line 188 
188            val expindex = specialize(alpha, 0)            val expindex = specialize(alpha, 0)
189            in            in
190              E.EIN{              E.EIN{
191                  params = [E.TEN(subst_flag, alpha), E.TEN(subst_flag, alpha)],                  params = [mkTEN alpha, mkTEN alpha],
192                  index = alpha,                  index = alpha,
193                  body = E.Op2(E.Sub, E.Tensor(0, expindex), E.Tensor(1, expindex))                  body = E.Op2(E.Sub, E.Tensor(0, expindex), E.Tensor(1, expindex))
194                }                }
# Line 187  Line 200 
200            val expindex = specialize(shape, 0)            val expindex = specialize(shape, 0)
201            in            in
202              E.EIN{              E.EIN{
203                  params = [E.TEN(subst_flag, shape), E.FLD dim],                  params = [mkTEN shape, E.FLD dim],
204                  index = shape,                  index = shape,
205                  body = E.Opn(E.Add,                  body = E.Opn(E.Add,
206                    [E.Lift(E.Tensor(0, expindex)), E.Op1(E.Neg, E.Field(1, expindex))])                    [E.Lift(E.Tensor(0, expindex)), E.Op1(E.Neg, E.Field(1, expindex))])
# Line 198  Line 211 
211            val expindex = specialize(shape, 0)            val expindex = specialize(shape, 0)
212            in            in
213              E.EIN{              E.EIN{
214                  params = [E.TEN(subst_flag, shape), E.FLD dim],                  params = [mkTEN shape, E.FLD dim],
215                  index = shape,                  index = shape,
216                  body = E.Op2(E.Sub, E.Field(1, expindex), E.Lift(E.Tensor(0, expindex)))                  body = E.Op2(E.Sub, E.Field(1, expindex), E.Lift(E.Tensor(0, expindex)))
217                }                }
# Line 221  Line 234 
234            val expindex = specialize(alpha, 0)            val expindex = specialize(alpha, 0)
235            in            in
236              E.EIN{              E.EIN{
237                  params = [E.TEN(subst_flag, []), E.TEN(subst_flag,alpha)],                  params = [mkTEN [], mkTEN alpha],
238                  index = alpha,                  index = alpha,
239                  body = E.Opn(E.Prod, [E.Tensor(0, []),  E.Tensor(1, expindex)])                  body = E.Opn(E.Prod, [E.Tensor(0, []),  E.Tensor(1, expindex)])
240                }                }
# Line 233  Line 246 
246           val expindex = specialize(shape, 0)           val expindex = specialize(shape, 0)
247           in           in
248              E.EIN{              E.EIN{
249               params = [E.TEN(subst_flag, []), E.FLD dim],               params = [mkTEN [], E.FLD dim],
250               index = shape,               index = shape,
251               body = E.Opn(E.Prod, [E.Lift( E.Tensor(0, [])), E.Field(1,expindex)])               body = E.Opn(E.Prod, [E.Lift( E.Tensor(0, [])), E.Field(1,expindex)])
252               }               }
# Line 243  Line 256 
256           val expindex = specialize(shape, 0)           val expindex = specialize(shape, 0)
257           in           in
258              E.EIN{              E.EIN{
259              params = [E.TEN(subst_flag,shape), E.FLD dim],              params = [mkTEN shape, E.FLD dim],
260              index = shape,              index = shape,
261              body = E.Opn(E.Prod, [E.Lift( E.Tensor(0,expindex)), E.Field(1, [])])              body = E.Opn(E.Prod, [E.Lift( E.Tensor(0,expindex)), E.Field(1, [])])
262              }              }
# Line 270  Line 283 
283            val expindex = specialize(alpha, 0)            val expindex = specialize(alpha, 0)
284            in            in
285              E.EIN{              E.EIN{
286                  params = [E.TEN(subst_flag, alpha), E.TEN(subst_flag, [])],                  params = [mkTEN alpha, mkTEN []],
287                  index = alpha,                  index = alpha,
288                  body = E.Op2(E.Div, E.Tensor(0, expindex), E.Tensor(1, []))                  body = E.Op2(E.Div, E.Tensor(0, expindex), E.Tensor(1, []))
289                }                }
# Line 282  Line 295 
295            val expindex = specialize(shape, 0)            val expindex = specialize(shape, 0)
296            in            in
297              E.EIN{              E.EIN{
298                  params = [E.FLD dim, E.TEN(subst_flag, [])],                  params = [E.FLD dim, mkTEN []],
299                  index = shape,                  index = shape,
300                  body = E.Op2(E.Div, E.Field(0, expindex), E.Lift(E.Tensor(1, [])))                  body = E.Op2(E.Div, E.Field(0, expindex), E.Lift(E.Tensor(1, [])))
301                }                }
# Line 300  Line 313 
313              E.EIN{              E.EIN{
314                  params = [E.FLD dim, E.FLD dim],                  params = [E.FLD dim, E.FLD dim],
315                  index = shape,                  index = shape,
316                  body = E.Opn(E.Prod, [E.Field(0, expindex), E.Op2(E.Div, E.B(E.Const 1), E.Field(1, []))])                  body = E.Opn(E.Prod, [E.Field(0, expindex), E.Op2(E.Div, E.Const 1, E.Field(1, []))])
317                }                }
318            end            end
319    
# Line 311  Line 324 
324              (*changed tensor lift variable here *)              (*changed tensor lift variable here *)
325            in            in
326              E.EIN {              E.EIN {
327                  params = [E.TEN(subst_flag, alpha)], index = alpha,                  params = [mkTEN alpha], index = alpha,
328                  body = E.Op1(E.Neg, E.Tensor(0, expindex))                  body = E.Op1(E.Neg, E.Tensor(0, expindex))
329                }                }
330            end            end
# Line 329  Line 342 
342    
343    (* 2-d cross product Eps_{ij}U_i V_j *)    (* 2-d cross product Eps_{ij}U_i V_j *)
344      val cross2TT = E.EIN{      val cross2TT = E.EIN{
345               params = [E.TEN(subst_flag, [2]), E.TEN(subst_flag, [2])],               params = [mkTEN [2], mkTEN [2]],
346               index = [],               index = [],
347               body = E.Sum([(E. V 0, 0, 1), (E.V 1, 0, 1)],               body = E.Sum([(0, 0, 1), (1, 0, 1)],
348               E.Opn(E.Prod, [E.G(E.Eps2(0, 1)), E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 1])]))               E.Opn(E.Prod, [E.Eps2(0, 1), E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 1])]))
349            }            }
350    
351    (* crossProduct is on 3D vectors ..vec3 t8=t0 × t1; *)    (* crossProduct is on 3D vectors ..vec3 t8=t0 × t1; *)
352      val cross3TT = E.EIN{      val cross3TT = E.EIN{
353               params = [E.TEN(subst_flag, [3]), E.TEN(subst_flag, [3])],               params = [mkTEN [3], mkTEN [3]],
354               index = [3],               index = [3],
355               body = E.Sum([(E.V 1, 0, 2), (E.V 2, 0, 2)],               body = E.Sum([(1, 0, 2), (2, 0, 2)],
356                  E.Opn(E.Prod, [                  E.Opn(E.Prod, [
357                      E.G(E.Epsilon(0, 1, 2)),                      E.Epsilon(0, 1, 2),
358                      E.Tensor(0, [E.V 1]),                      E.Tensor(0, [E.V 1]),
359                      E.Tensor(1, [E.V 2])                      E.Tensor(1, [E.V 2])
360                    ]))                    ]))
# Line 350  Line 363 
363    (* Field Cross Product *)    (* Field Cross Product *)
364      val cross2FF = E.EIN{      val cross2FF = E.EIN{
365              params = [E.FLD(2), E.FLD(2)], index = [],              params = [E.FLD(2), E.FLD(2)], index = [],
366              body = E.Sum([(E.V 0, 0, 1), (E.V 1, 0, 1)],              body = E.Sum([(0, 0, 1), (1, 0, 1)],
367                  E.Opn(E.Prod, [E.G(E.Eps2(0, 1)), E.Field(0, [E.V 0]), E.Field(1, [E.V 1])]))                  E.Opn(E.Prod, [E.Eps2(0, 1), E.Field(0, [E.V 0]), E.Field(1, [E.V 1])]))
368            }            }
369    
370    (* Field Cross Product *)    (* Field Cross Product *)
371      val cross3FF = E.EIN{      val cross3FF = E.EIN{
372              params = [E.FLD(3), E.FLD(3)],index= [3],              params = [E.FLD(3), E.FLD(3)],index= [3],
373              body = E.Sum([(E.V 1, 0, 2), (E.V 2, 0, 2)],              body = E.Sum([(1, 0, 2), (2, 0, 2)],
374                  E.Opn(E.Prod, [E.G(E.Epsilon(0, 1, 2)),                  E.Opn(E.Prod, [E.Epsilon(0, 1, 2),
375                  E.Field(0, [E.V 1]), E.Field(1, [E.V 2])]))                  E.Field(0, [E.V 1]), E.Field(1, [E.V 2])]))
376            }            }
377    
378    (******************** outer product ********************************)    (******************** outer product ********************************)
379    
380  (* QUESTION: can we generalize outer product? *)    fun outerTT (alpha, beta) = let
381    (*Vector Examples : <T_i * T_j>_ij..t0⊗t1*)          val expIdxA = specialize (alpha, 0)
382      fun outerTT (dimA, dimB) = E.EIN{          val expIdxB = specialize (beta, length alpha)
383              params = [E.TEN(subst_flag, [dimA]), E.TEN(subst_flag, [dimB])],          in
384              index = [dimA, dimB],            E.EIN{
385              body = E.Opn(E.Prod, [E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 1])])                params = [mkTEN alpha, mkTEN beta],
386            }                index = alpha@beta,
387                  body = E.Opn(E.Prod, [E.Tensor(0, expIdxA), E.Tensor(1, expIdxB)])
     fun outerTM (i, [j, k]) = E.EIN{  
             params = [E.TEN(subst_flag, [i]), E.TEN(subst_flag, [j, k])],  
             index = [i, j, k],  
             body = E.Opn(E.Prod, [E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 1, E.V 2])])  
           }  
   
     fun outerMT ([i, j], k) = E.EIN{  
             params = [E.TEN(subst_flag, [i, j]), E.TEN(subst_flag, [k])],  
             index = [i, j, k],  
             body = E.Opn(E.Prod, [E.Tensor(0, [E.V 0, E.V 1]), E.Tensor(1, [E.V 2])])  
388            }            }
389            end
390    
391      (*Assumes same dimension vector field *)      (*Assumes same dimension vector field *)
392      fun outerFF (dim, i, j) = E.EIN{      fun outerFF (dim, alpha, beta) =let
393            val expIdxA = specialize (alpha, 0)
394            val expIdxB = specialize (beta, length alpha)
395            in
396              E.EIN{
397              params = [E.FLD dim, E.FLD dim],              params = [E.FLD dim, E.FLD dim],
398              index = [i, j],                index = alpha@beta,
399              body = E.Opn(E.Prod, [E.Field(0, [E.V 0]), E.Field(1, [E.V 1])])                body = E.Opn(E.Prod, [E.Field(0, expIdxA), E.Field(1, expIdxB)])
400                }
401            end
402    
403        fun outerTF (dim, alpha, beta) =let
404            val expIdxA = specialize (alpha, 0)
405            val expIdxB = specialize (beta, length alpha)
406            in
407              E.EIN{
408                  params = [mkTEN alpha, E.FLD dim],
409                  index = alpha@beta,
410                  body = E.Opn(E.Prod, [E.Lift(E.Tensor(0, expIdxA)), E.Field(1, expIdxB)])
411            }            }
412            end
413    
414        fun outerFT (dim, alpha, beta) =let
415            val expIdxA = specialize(alpha, 0)
416            val expIdxB = specialize(beta, length alpha)
417            in
418              E.EIN{
419                  params = [E.FLD dim, mkTEN alpha],
420                  index = alpha@beta,
421                  body = E.Opn(E.Prod, [E.Field(0, expIdxA), E.Lift(E.Tensor(1, expIdxB))])
422                }
423            end
424    
425    (*************************** inner product **********************************)    (*************************** inner product **********************************)
426      (* generic inner product: <T_{\alpha i} * T_{i \beta}>_{\alpha \beta} *)      (* generic inner product: <T_{\alpha i} * T_{i \beta}>_{\alpha \beta} *)
# Line 397  Line 428 
428            val alpha = List.take(shape1, length shape1 - 1)            val alpha = List.take(shape1, length shape1 - 1)
429            val expindexA = specialize(alpha, 0)            val expindexA = specialize(alpha, 0)
430            val expindexB = specialize(beta, length alpha)            val expindexB = specialize(beta, length alpha)
431            val s' = E.V(length alpha + length beta)            val sid = length alpha + length beta
432            val s'' = [(s', 0, i-1)]            val sx = E.V sid
433              val s'' = [(sid, 0, i-1)]
434            in            in
435              E.EIN{              E.EIN{
436                  params = [E.TEN(subst_flag, shape1), E.TEN(subst_flag, i::beta)],                  params = [mkTEN shape1, mkTEN(i :: beta)],
437                  index = alpha@beta,                  index = alpha@beta,
438                  body = E.Sum(s'', E.Opn(E.Prod, [                  body = E.Sum(s'', E.Opn(E.Prod, [
439                      E.Tensor(0, expindexA@[s']),   (* T_{\alpha i} *)                      E.Tensor(0, expindexA@[sx]),   (* T_{\alpha i} *)
440                      E.Tensor(1, [s']@expindexB )   (* T'_{i \beta} *)                      E.Tensor(1, [sx]@expindexB )   (* T'_{i \beta} *)
441                    ]))                    ]))
442                }                }
443            end            end
# Line 416  Line 448 
448            val alpha = List.take(shape1, length shape1 - 1)            val alpha = List.take(shape1, length shape1 - 1)
449            val expindexA = specialize(alpha, 0)            val expindexA = specialize(alpha, 0)
450            val expindexB = specialize(beta, length alpha)            val expindexB = specialize(beta, length alpha)
451            val sid = E.V(length alpha + length beta)            val sid = length alpha + length beta
452              val sx = E.V sid
453            in            in
454              E.EIN{              E.EIN{
455                  params = [E.FLD dim, E.FLD dim],                  params = [E.FLD dim, E.FLD dim],
456                  index = alpha@beta,                  index = alpha@beta,
457                  body = E.Sum([(sid, 0, i-1)],                  body = E.Sum([(sid, 0, i-1)],
458                    E.Opn(E.Prod, [                    E.Opn(E.Prod, [
459                        E.Field(0, expindexA@[sid]),   (* F_{\alpha i} *)                        E.Field(0, expindexA @ [sx]),   (* F_{\alpha i} *)
460                        E.Field(1, [sid]@expindexB)    (* F'_{i \beta} *)                        E.Field(1, [sx] @ expindexB)    (* F'_{i \beta} *)
461                      ]))                      ]))
462                }                }
463            end            end
# Line 434  Line 467 
467            val alpha = List.take(shape1, length shape1-1)            val alpha = List.take(shape1, length shape1-1)
468            val expindexA = specialize(alpha, 0)            val expindexA = specialize(alpha, 0)
469            val expindexB = specialize(beta, length alpha)            val expindexB = specialize(beta, length alpha)
470            val sid = E.V(length alpha + length beta)            val sid = length alpha + length beta
471              val sx = E.V sid
472            in            in
473              E.EIN{              E.EIN{
474                  params = [E.FLD dim, E.TEN(subst_flag, i::beta)],                  params = [E.FLD dim, mkTEN(i::beta)],
475                  index = alpha@beta,                  index = alpha@beta,
476                  body = E.Sum([(sid, 0, i-1)],                  body = E.Sum([(sid, 0, i-1)],
477                    E.Opn(E.Prod, [                    E.Opn(E.Prod, [
478                        E.Field(0, expindexA@[sid]),           (* F_{\alpha i} *)                        E.Field(0, expindexA @ [sx]),           (* F_{\alpha i} *)
479                        E.Lift(E.Tensor(1, [sid]@expindexB ))  (* F'_{i \beta} *)                        E.Lift(E.Tensor(1, [sx] @ expindexB ))  (* F'_{i \beta} *)
480                      ]))                      ]))
481                }                }
482            end            end
# Line 452  Line 486 
486            val alpha = List.take(shape1, length shape1 - 1)            val alpha = List.take(shape1, length shape1 - 1)
487            val expindexA = specialize(alpha, 0)            val expindexA = specialize(alpha, 0)
488            val expindexB = specialize(beta, length alpha)            val expindexB = specialize(beta, length alpha)
489            val sid = E.V(length(alpha) + length beta)            val sid = length(alpha) + length beta
490              val sx = E.V sid
491            in            in
492              E.EIN{              E.EIN{
493                  params = [E.TEN(subst_flag,shape1), E.FLD dim],index = alpha@beta,                  params = [mkTEN shape1, E.FLD dim],
494                    index = alpha @ beta,
495                  body = E.Sum([(sid, 0, i-1)],                  body = E.Sum([(sid, 0, i-1)],
496                    E.Opn(E.Prod, [                    E.Opn(E.Prod, [
497                        E.Lift(E.Tensor(0, expindexA@[sid])),   (* F_{\alpha i} *)                        E.Lift(E.Tensor(0, expindexA @ [sx])),   (* F_{\alpha i} *)
498                        E.Field(1, [sid]@expindexB)             (* F'_{i \beta} *)                        E.Field(1, [sx] @ expindexB)             (* F'_{i \beta} *)
499                      ]))                      ]))
500                }                }
501            end            end
# Line 475  Line 511 
511            val expindexB = specialize(beta, lenAlpha)            val expindexB = specialize(beta, lenAlpha)
512            val sumi = lenAlpha + length beta            val sumi = lenAlpha + length beta
513            val s' = [E.V sumi, E.V(sumi+1)]            val s' = [E.V sumi, E.V(sumi+1)]
514            val sx = [(E.V sumi, 0, i-1), (E.V(sumi+1), 0, j-1)]            val sx = [(sumi, 0, i-1), ((sumi+1), 0, j-1)]
515            in            in
516              E.EIN{              E.EIN{
517                  params = [E.TEN(subst_flag, shape1), E.TEN(subst_flag, i::j::beta)],                  params = [mkTEN shape1, mkTEN(i::j::beta)],
518                  index = alpha@beta,                  index = alpha@beta,
519                  body = E.Sum(sx,                  body = E.Sum(sx,
520                    E.Opn(E.Prod, [E.Tensor(0, expindexA@s'), E.Tensor(1, s'@expindexB)]))                    E.Opn(E.Prod, [E.Tensor(0, expindexA@s'), E.Tensor(1, s'@expindexB)]))
# Line 493  Line 529 
529            val expindexB = specialize(beta, lenAlpha)            val expindexB = specialize(beta, lenAlpha)
530            val sumi = lenAlpha + length beta            val sumi = lenAlpha + length beta
531            val s' = [E.V sumi, E.V(sumi+1)]            val s' = [E.V sumi, E.V(sumi+1)]
532            val sx = [(E.V sumi, 0, i-1), (E.V(sumi+1), 0, j-1)]            val sx = [(sumi, 0, i-1), ((sumi+1), 0, j-1)]
533            in            in
534              E.EIN{              E.EIN{
535                  params = [E.FLD dim, E.FLD dim],                  params = [E.FLD dim, E.FLD dim],
# Line 510  Line 546 
546            val alpha = List.take(shape1, lenAlpha)            val alpha = List.take(shape1, lenAlpha)
547            val expindexA = specialize(alpha, 0)            val expindexA = specialize(alpha, 0)
548            val expindexB = specialize(beta, lenAlpha)            val expindexB = specialize(beta, lenAlpha)
549            val sumi = lenAlpha + length beta            val sid = lenAlpha + length beta
550            val s' = [E.V sumi, E.V(sumi+1)]            val s' = [E.V sid, E.V(sid+1)]
551            val sx = [(E.V sumi, 0, i-1), (E.V(sumi+1), 0, j-1)]            val sx = [(sid, 0, i-1), ((sid+1), 0, j-1)]
552            in            in
553              E.EIN{              E.EIN{
554                  params = [E.FLD dim, E.TEN(subst_flag,shape1)],                  params = [E.FLD dim, mkTEN shape1],
555                  index = alpha@beta,                  index = alpha@beta,
556                  body = E.Sum(sx,                  body = E.Sum(sx,
557                    E.Opn(E.Prod, [E.Field(0, expindexA@s'), E.Lift(E.Tensor(1, s'@expindexB))]))                    E.Opn(E.Prod, [E.Field(0, expindexA@s'), E.Lift(E.Tensor(1, s'@expindexB))]))
# Line 528  Line 564 
564            val alpha = List.take(shape1, lenAlpha)            val alpha = List.take(shape1, lenAlpha)
565            val expindexA = specialize(alpha, 0)            val expindexA = specialize(alpha, 0)
566            val expindexB = specialize(beta, lenAlpha)            val expindexB = specialize(beta, lenAlpha)
567            val sumi = lenAlpha + length beta            val sid = lenAlpha + length beta
568            val s' = [E.V sumi, E.V(sumi+1)]            val s' = [E.V sid, E.V(sid+1)]
569            val sx = [(E.V sumi, 0, i-1), (E.V(sumi+1), 0, j-1)]            val sx = [(sid, 0, i-1), ((sid+1), 0, j-1)]
570            in            in
571              E.EIN{              E.EIN{
572                  params = [E.TEN(subst_flag, i::j::beta), E.FLD dim],                  params = [mkTEN(i::j::beta), E.FLD dim],
573                  index = alpha@beta,                  index = alpha@beta,
574                  body = E.Sum(sx,                  body = E.Sum(sx,
575                    E.Opn(E.Prod, [E.Lift(E.Tensor(0, expindexA@s')), E.Field(1, s'@expindexB)]))                    E.Opn(E.Prod, [E.Lift(E.Tensor(0, expindexA@s')), E.Field(1, s'@expindexB)]))
# Line 542  Line 578 
578    
579    (******************** Norm  ********************************)    (******************** Norm  ********************************)
580    
581          (*n.t.s tensor norms/normalize use high-il ops      fun normT alpha = let
582          *we can norm any size and use einapp            val expIdx = specialize(alpha, 0)
         * normalize only implemented for vectors and use mid il-op  
         *)  
   (* get norm, but without the sqrt. Implemented as a summation over a modulate *)  
     fun magnitudeTT alpha = let  
           val expindex = specialize(alpha, 0)  
583            val sx = sumIds(length alpha, 0, alpha)            val sx = sumIds(length alpha, 0, alpha)
584            in            in
585               E.EIN{               E.EIN{
586                   params = [E.TEN(subst_flag,alpha), E.TEN(subst_flag,alpha)],                  params = [mkTEN alpha],
587                   index = [],                   index = [],
588                   body = E.Sum(sx,                  body = E.Op1(E.Sqrt,
589                   E.Opn(E.Prod, [E.Tensor(0, expindex), E.Tensor(1, expindex)]))                    E.Sum(sx, E.Opn(E.Prod, [E.Tensor(0, expIdx), E.Tensor(0, expIdx)])))
590                 }                 }
591            end            end
592    
593      fun magnitudeFF (dim, []) = E.EIN{      fun normF (dim, alpha) =let
594              params = [E.FLD dim, E.FLD dim], index = [], body = E.Field(0, [])            val expIdx = specialize(alpha, 0)
           }  
       | magnitudeFF (dim, alpha) =let  
           val expindex = specialize(alpha, 0)  
595            val sx = sumIds(length alpha, 0, alpha)            val sx = sumIds(length alpha, 0, alpha)
596            in            in
597              E.EIN{              E.EIN{
598                  params = [E.FLD dim, E.FLD dim],                  params = [E.FLD dim],
599                  index = [],                  index = [],
600                  body = E.Op1(E.Sqrt,                  body = E.Op1(E.Sqrt,
601                    E.Sum(sx, E.Opn(E.Prod, [E.Field(0, expindex), E.Field(1, expindex)])))                    E.Sum(sx, E.Opn(E.Prod, [E.Field(0, expIdx), E.Field(0, expIdx)])))
602                }                }
603            end            end
604    
605      fun normalizeTT [] = E.EIN{      fun normalizeTT alpha = let
             params = [E.TEN(subst_flag, [])], index = [], body = E.Tensor(0, [])  
           }  
       | normalizeTT alpha = let  
606            val expindex = specialize(alpha, 0)            val expindex = specialize(alpha, 0)
         (* shift indices in the inner product *)  
607            val len = length alpha            val len = length alpha
608            val expindexDot = specialize(alpha, len)            val expindexDot = specialize(alpha, len)
609            val sx = sumIds(len, len, alpha)            val sx = sumIds(len, len, alpha)
# Line 587  Line 611 
611            val g = E.Tensor(1, expindexDot)            val g = E.Tensor(1, expindexDot)
612            in            in
613              E.EIN{              E.EIN{
614                  params = [E.TEN(subst_flag, alpha), E.TEN(subst_flag,alpha)],                  params = [mkTEN alpha, mkTEN alpha],
615                  index = alpha,                  index = alpha,
616                  body = E.Opn(E.Prod, [                  body = E.Opn(E.Prod, [
617                      f, E.Op2(E.Div, E.B(E.Const 1), E.Op1(E.Sqrt, E.Sum(sx, E.Opn(E.Prod, [g, g]))))                      f, E.Op2(E.Div, E.Const 1, E.Op1(E.Sqrt, E.Sum(sx, E.Opn(E.Prod, [g, g]))))
618                    ])                    ])
619                }                }
620            end            end
621    
622      fun normalizeFF (dim, []) = E.EIN{      fun normalizeFF (dim, alpha as i::_) = let
             params = [E.FLD dim], index = [], body = E.Field(0, [])  
           }  
       | normalizeFF (dim, alpha as i::_) = let  
623            val expindex = specialize(alpha, 0)            val expindex = specialize(alpha, 0)
         (*shift indices in the inner product*)  
624            val len = length alpha            val len = length alpha
625            val expindexDot = specialize(alpha, len)            val expindexDot = specialize(alpha, len)
626            val sx = sumIds(len, len, alpha)            val sx = sumIds(len, len, alpha)
# Line 609  Line 629 
629            in            in
630              E.EIN{              E.EIN{
631                  params = [E.FLD dim, E.FLD dim],                  params = [E.FLD dim, E.FLD dim],
632                  index = [dim],                  index = alpha,
633                  body = E.Opn(E.Prod, [                  body = E.Opn(E.Prod, [
634                      f, E.Op2(E.Div, E.B(E.Const 1), E.Op1(E.Sqrt, E.Sum(sx, E.Opn(E.Prod, [g, g]))))                      f, E.Op2(E.Div, E.Const 1, E.Op1(E.Sqrt, E.Sum(sx, E.Opn(E.Prod, [g, g]))))
635                    ])                    ])
636                }                }
637            end            end
# Line 620  Line 640 
640    
641    (* Trace: <M_{i, i}>  This one Sx represents both i's*)    (* Trace: <M_{i, i}>  This one Sx represents both i's*)
642      fun traceT dim = E.EIN{      fun traceT dim = E.EIN{
643              params = [E.TEN(1, [dim, dim])], index = [],              params = [mkTEN [dim, dim]], index = [],
644              body = E.Sum([(E.V 0, 0, dim-1)], E.Tensor(0, [E.V 0, E.V 0]))              body = E.Sum([(0, 0, dim-1)], E.Tensor(0, [E.V 0, E.V 0]))
645            }            }
646    
647    (* Trace: <Sigma_i F_{\alpha i, i}>  This one Sx represents both i's *)    (* Trace: <Sigma_i F_{\alpha i, i}>  This one Sx represents both i's *)
648      fun traceF (dim, alpha) = let      fun traceF (dim, alpha) = let
649            val expindex = specialize(alpha, 0)            val expindex = specialize(alpha, 0)
650            val s = E.V(length alpha)            val sid = length alpha
651              val sx = E.V sid
652            in            in
653              E.EIN{              E.EIN{
654                  params = [E.FLD dim],                  params = [E.FLD dim],
655                  index = alpha,                  index = alpha,
656                  body = E.Sum([(s, 0, dim-1)], E.Field(0, expindex@[s, s]))                  body = E.Sum([(sid, 0, dim-1)], E.Field(0, expindex@[sx, sx]))
657                }                }
658            end            end
659    
660    (************************* tranpose *************************)    (************************* tranpose *************************)
661    
662      fun transposeT alpha = E.EIN{      fun transposeT alpha = E.EIN{
663              params = [E.TEN(subst_flag, alpha)],              params = [mkTEN alpha],
664              index = List.rev alpha,              index = List.rev alpha,
665              body = E.Tensor(0, [E.V 1, E.V 0])              body = E.Tensor(0, [E.V 1, E.V 0])
666            }            }
# Line 654  Line 675 
675    (************************* determinant *************************)    (************************* determinant *************************)
676    
677      val det2T = E.EIN{      val det2T = E.EIN{
678              params = [E.TEN(0, [2, 2])],              params = [mkNoSubstTEN [2, 2]],
679              index = [],              index = [],
680              body = E.Op2(E.Sub,              body = E.Op2(E.Sub,
681                E.Opn(E.Prod, [E.Tensor(0, [E.C 0, E.C 0]), E.Tensor(0, [E.C 1, E.C 1])]),                E.Opn(E.Prod, [E.Tensor(0, [E.C 0, E.C 0]), E.Tensor(0, [E.C 1, E.C 1])]),
# Line 673  Line 694 
694            val i = E.Tensor(0, [E.C 2, E.C 2])            val i = E.Tensor(0, [E.C 2, E.C 2])
695            in            in
696              E.EIN{              E.EIN{
697                  params = [E.TEN(0, [3, 3])],                  params = [mkNoSubstTEN [3, 3]],
698                  index = [],                  index = [],
699                  body = E.Op2(E.Sub,                  body = E.Op2(E.Sub,
700                    E.Opn(E.Add, [                    E.Opn(E.Add, [
# Line 720  Line 741 
741      val det3FA = E.EIN{      val det3FA = E.EIN{
742              params = [E.FLD 3],              params = [E.FLD 3],
743              index = [],              index = [],
744              body = E.Sum([(E.V 0, 0, 2), (E.V 1, 0, 2), (E.V 2, 0, 2)],              body = E.Sum([(0, 0, 2), (1, 0, 2), (2, 0, 2)],
745                E.Opn(E.Prod, [                E.Opn(E.Prod, [
746                    E.G(E.Epsilon(0, 1, 2)),                    E.Epsilon(0, 1, 2),
747                    E.Field(0, [E.C 0, E. V 0]),                    E.Field(0, [E.C 0, E. V 0]),
748                    E.Field(0, [E.C 1, E. V 1]),                    E.Field(0, [E.C 1, E. V 1]),
749                    E.Field(0, [E.C 2, E. V 2])                    E.Field(0, [E.C 2, E. V 2])
# Line 732  Line 753 
753      val det3F = E.EIN{      val det3F = E.EIN{
754              params = [E.FLD 3],              params = [E.FLD 3],
755              index = [],              index = [],
756              body = E.Sum([(E.V 0, 0, 2)],              body = E.Sum([(0, 0, 2)],
757                E.Opn(E.Prod, [                E.Opn(E.Prod, [
758                    E.Field(0, [E.C 0, E. V 0]),                    E.Field(0, [E.C 0, E. V 0]),
759                    E.Sum([(E.V 1, 0, 2)],                    E.Sum([(1, 0, 2)],
760                      E.Opn(E.Prod, [                      E.Opn(E.Prod, [
761                          E.Field(0, [E.C 1, E. V 1]),                          E.Field(0, [E.C 1, E. V 1]),
762                          E.Sum([(E.V 2, 0, 2)],                          E.Sum([(2, 0, 2)],
763                            E.Opn(E.Prod, [E.G(E.Epsilon(0, 1, 2)), E.Field(0, [E.C 2, E. V 2])]))                            E.Opn(E.Prod, [E.Epsilon(0, 1, 2), E.Field(0, [E.C 2, E.V 2])]))
764                        ]))                        ]))
765                  ]))                  ]))
766            }            }
767    
768    (************************* Exponential **************************)    (************************* Exponential **************************)
769      fun expF dim = E.EIN{params = [E.FLD dim], index = [], body = E.Op1(E.Exp, E.Field(0, []))}      fun expF dim = E.EIN{params = [E.FLD dim], index = [], body = E.Op1(E.Exp, E.Field(0, []))}
770      val expT = E.EIN{params = [E.TEN(0, [])], index = [], body = E.Op1(E.Exp, E.Tensor(0, []))}      val expT = E.EIN{params = [mkNoSubstTEN []], index = [], body = E.Op1(E.Exp, E.Tensor(0, []))}
771    
772    (************************* Lifted single-argument math functions *************************)    (************************* Lifted single-argument math functions *************************)
773      local      local
774        fun liftFn f dim = E.EIN{        fun tensorFn rator = E.EIN{
775                  params = [mkNoSubstTEN []],
776                  index = [],
777                  body = E.Op1(rator, E.Tensor(0, []))
778                }
779          fun liftFn rator dim = E.EIN{
780                params = [E.FLD dim],                params = [E.FLD dim],
781                index = [],                index = [],
782                body = E.Op1(E.Cosine, E.Field(0, []))                body = E.Op1(rator, E.Field(0, []))
783              }              }
784      in      in
785      fun powF (dim, n) = E.EIN{      fun powFI (dim, n) = E.EIN{
786              params = [E.FLD dim],              params = [E.FLD dim],
787              index = [], body = E.Op1(E.PowInt n, E.Field(0, []))              index = [], body = E.Op1(E.PowInt n, E.Field(0, []))
788            }            }
789        val sqrtR = tensorFn E.Sqrt
790      val sqrtF = liftFn E.Sqrt      val sqrtF = liftFn E.Sqrt
791        val cosR  = tensorFn E.Cosine
792      val cosF = liftFn E.Cosine      val cosF = liftFn E.Cosine
793        val acosR = tensorFn E.ArcCosine
794      val acosF = liftFn E.ArcCosine      val acosF = liftFn E.ArcCosine
795        val sinR  = tensorFn E.Sine
796      val sinF = liftFn E.Sine      val sinF = liftFn E.Sine
797        val asinR = tensorFn E.ArcSine
798      val asinF = liftFn E.ArcSine      val asinF = liftFn E.ArcSine
799        val tanR  = tensorFn E.Tangent
800      val tanF = liftFn E.Tangent      val tanF = liftFn E.Tangent
801        val atanR = tensorFn E.ArcTangent
802      val atanF = liftFn E.ArcTangent      val atanF = liftFn E.ArcTangent
803      end (* local *)      end (* local *)
804    
805    (************************* other tensor ops *************************)    (************************* other tensor ops *************************)
806      fun modulate dim = E.EIN{      fun modulate dim = E.EIN{
807              params = [E.TEN(subst_flag, [dim]), E.TEN(subst_flag, [dim])],              params = [mkTEN [dim], mkTEN [dim]],
808              index = [dim],              index = [dim],
809              body = E.Opn(E.Prod, [E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 0])])              body = E.Opn(E.Prod, [E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 0])])
810            }            }
811    
812      fun identity dim = E.EIN{      fun identity dim = E.EIN{
813              params = [], index = [dim, dim], body = E.G(E.Delta(E.V(0), E.V(1)))              params = [], index = [dim, dim], body = E.Delta(0, 1)
814            }            }
815    
816      fun zeros shape = E.EIN{      fun zeros shape = E.EIN{
817              params = [], index = shape, body = E.B(E.Const 0)              params = [], index = shape, body = E.Const 0
818            }            }
819    
820  (* QUESTION: why do we need the const list?  The indices are implicit in the position of  (* QUESTION: why do we need the const list?  The indices are implicit in the position of
# Line 795  Line 828 
828            val ix = iter(mask, const, 0)            val ix = iter(mask, const, 0)
829            in            in
830              E.EIN{              E.EIN{
831                  params = [E.TEN(subst_flag, argTy)],                  params = [mkTEN argTy],
832                  index = rstTy,                  index = rstTy,
833                  body = E.Tensor(0, ix)                  body = E.Tensor(0, ix)
834                }                }
# Line 819  Line 852 
852            val expindex = specialize(alpha, 0)            val expindex = specialize(alpha, 0)
853            in            in
854              E.EIN{              E.EIN{
855                  params = [E.FLD dim, E.TEN(0, [])], index = alpha,                  params = [E.FLD dim, mkNoSubstTEN []], index = alpha,
856                  body = E.Probe(E.Field(0, expindex), E.Tensor(1, []))                  body = E.Probe(E.Field(0, expindex), E.Tensor(1, []))
857                }                }
858            end            end
# Line 830  Line 863 
863      val curl2d = E.EIN{      val curl2d = E.EIN{
864              params = [E.FLD 2],              params = [E.FLD 2],
865              index = [],              index = [],
866              body = E.Sum([(E.V 0, 0, 1), (E.V 1, 0, 1)],              body = E.Sum([(0, 0, 1), (1, 0, 1)],
867                E.Opn(E.Prod, [                E.Opn(E.Prod, [
868                    E.G(E.Eps2(0, 1)),                    E.Eps2(0, 1),
869                    E.Apply(E.Partial[E.V 0], E.Field(0, [E.V 1]))                    E.Apply(E.Partial[E.V 0], E.Field(0, [E.V 1]))
870                  ]))                  ]))
871            }            }
872    
873      val curl3d = E.EIN{      val curl3d = E.EIN{
874              params = [E.TEN(1, [3])],              params = [mkTEN [3]],
875              index = [3],              index = [3],
876              body = E.Sum([(E.V 1, 0, 2), (E.V 2, 0, 2)],              body = E.Sum([(1, 0, 2), (2, 0, 2)],
877                E.Opn(E.Prod, [                E.Opn(E.Prod, [
878                    E.G(E.Epsilon(0, 1, 2)),                    E.Epsilon(0, 1, 2),
879                    E.Apply(E.Partial[E.V 1], E.Field(0, [E.V 2]))                    E.Apply(E.Partial[E.V 1], E.Field(0, [E.V 2]))
880                  ]))                  ]))
881            }            }
# Line 876  Line 909 
909    (*  <d F_i /d_i> *)    (*  <d F_i /d_i> *)
910      fun divergence (dim, alpha) = let      fun divergence (dim, alpha) = let
911            val expindex = specialize(alpha, 0)            val expindex = specialize(alpha, 0)
912            val sumI = length alpha            val sid = length alpha
913            val sumIndex = E.V sumI            val sumIndex = E.V sid
914            val sumIndexL = [sumIndex]            val sumIndexL = [sumIndex]
915            val S = expindex@sumIndexL            val S = expindex@sumIndexL
916            in            in
917              E.EIN{              E.EIN{
918                  params = [E.FLD dim],                  params = [E.FLD dim],
919                  index = alpha,                  index = alpha,
920                  body = E.Sum([(sumIndex, 0, dim-1)], E.Apply(E.Partial sumIndexL, E.Field(0, S)))                  body = E.Sum([(sid, 0, dim-1)], E.Apply(E.Partial sumIndexL, E.Field(0, S)))
921                }                }
922            end            end
923    

Legend:
Removed from v.3478  
changed lines
  Added in v.3978

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