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 3495, Fri Dec 11 20:34:26 2015 UTC revision 3978, Wed Jun 15 19:07:40 2016 UTC
# Line 48  Line 48 
48    
49      val outerTT : shape * shape -> Ein.ein      val outerTT : shape * shape -> Ein.ein
50      val outerFF : dim * shape * shape -> Ein.ein      val outerFF : dim * shape * shape -> Ein.ein
51        val outerTF : dim * shape * shape -> Ein.ein
52        val outerFT : dim * shape * shape -> 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 82  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
   
     val sqrtF : dim -> Ein.ein  
     val cosF  : dim -> Ein.ein  
     val acosF : dim -> Ein.ein  
     val sinF  : dim -> Ein.ein  
     val asinF : dim -> Ein.ein  
     val tanF  : dim -> Ein.ein  
     val atanF : dim -> Ein.ein  
88      val sqrtR : Ein.ein      val sqrtR : Ein.ein
89        val sqrtF : dim -> Ein.ein
90      val cosR  : Ein.ein      val cosR  : Ein.ein
91        val cosF  : dim -> Ein.ein
92      val acosR : Ein.ein      val acosR : Ein.ein
93        val acosF : dim -> Ein.ein
94      val sinR  : Ein.ein      val sinR  : Ein.ein
95        val sinF  : dim -> Ein.ein
96      val asinR : Ein.ein      val asinR : Ein.ein
97        val asinF : dim -> Ein.ein
98      val tanR  : Ein.ein      val tanR  : Ein.ein
99        val tanF  : dim -> Ein.ein
100      val atanR :  Ein.ein      val atanR :  Ein.ein
101        val atanF : dim -> Ein.ein
102    
103      val modulate : dim -> Ein.ein      val modulate : dim -> Ein.ein
104    
# Line 123  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 142  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 155  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 178  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 190  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 201  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 224  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 236  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 246  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 273  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 285  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 303  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 314  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 332  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 353  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    fun outerTT(alpha,beta) =let    fun outerTT(alpha,beta) =let
381      val expindexA= specialize(alpha,0)          val expIdxA = specialize (alpha, 0)
382      val expindexB= specialize(beta,length(alpha))          val expIdxB = specialize (beta, length alpha)
383      in      in
384          E.EIN{          E.EIN{
385              params = [E.TEN(subst_flag,alpha), E.TEN(subst_flag,beta)],                params = [mkTEN alpha, mkTEN beta],
386              index= alpha@beta,              index= alpha@beta,
387              body= E.Opn(E.Prod,[E.Tensor(0,  expindexA), E.Tensor(1,  expindexB)])                body = E.Opn(E.Prod, [E.Tensor(0, expIdxA), E.Tensor(1, expIdxB)])
388          }          }
389          end          end
390    
391      (*Assumes same dimension vector field *)      (*Assumes same dimension vector field *)
392      fun outerFF(dim,alpha,beta) =let      fun outerFF(dim,alpha,beta) =let
393      val expindexA= specialize(alpha,0)          val expIdxA = specialize (alpha, 0)
394      val expindexB= specialize(beta,length(alpha))          val expIdxB = specialize (beta, length alpha)
395      in E.EIN{          in
396          params = [E.FLD(dim),E.FLD(dim)],            E.EIN{
397                  params = [E.FLD dim, E.FLD dim],
398          index = alpha@beta,          index = alpha@beta,
399          body = E.Opn(E.Prod,[E.Field(0, expindexA),E.Field(1, expindexB)])                body = E.Opn(E.Prod, [E.Field(0, expIdxA), E.Field(1, expIdxB)])
400          }          }
401      end      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 395  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 414  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 432  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 450  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 473  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 491  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 508  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 526  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 540  Line 578 
578    
579    (******************** Norm  ********************************)    (******************** Norm  ********************************)
580    
         (*n.t.s tensor norms/normalize use high-il ops  
         *we can norm any size and use einapp  
         * normalize only implemented for vectors and use mid il-op  
         *)  
   (* get norm, but without the sqrt. Implemented as a summation over a modulate *)  
581    fun normT alpha = let    fun normT alpha = let
582      val expindex= specialize(alpha,0)            val expIdx = 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)],                  params = [mkTEN alpha],
587          index = [],          index = [],
588          body = E.Op1(E.Sqrt,E.Sum(sx, E.Opn(E.Prod,[E.Tensor(0, expindex), E.Tensor(0, expindex)])))                  body = E.Op1(E.Sqrt,
589                      E.Sum(sx, E.Opn(E.Prod, [E.Tensor(0, expIdx), E.Tensor(0, expIdx)])))
590              }              }
591      end      end
592    
593    fun normF(dim,alpha) =let    fun normF(dim,alpha) =let
594      val expindex= specialize(alpha,0)            val expIdx = 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)],                  params = [E.FLD dim],
599      index = [],      index = [],
600      body = E.Op1(E.Sqrt,E.Sum(sx, E.Opn(E.Prod,[E.Field(0, expindex),E.Field(0,expindex)])))                  body = E.Op1(E.Sqrt,
601                      E.Sum(sx, E.Opn(E.Prod, [E.Field(0, expIdx), E.Field(0, expIdx)])))
602          }          }
603      end      end
604    
# Line 576  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
# Line 594  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 605  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 639  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 658  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 705  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 717  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 op1 dim = E.EIN{        fun tensorFn rator = E.EIN{
775                params = [E.FLD dim],                params = [mkNoSubstTEN []],
776                index = [],                index = [],
777                body = E.Op1(op1, E.Field(0, []))                body = E.Op1(rator, E.Tensor(0, []))
778              }              }
779          fun op1Fn op0= E.EIN{        fun liftFn rator dim = E.EIN{
780              params = [E.TEN(0,[])],                params = [E.FLD dim],
781              index = [],              index = [],
782              body = E.Op1(op0, 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
     val sqrtR =op1Fn E.Sqrt  
     val acosR = op1Fn E.ArcCosine  
     val sinR = op1Fn E.Sine  
     val asinR = op1Fn E.ArcSine  
     val tanR = op1Fn E.Tangent  
     val atanR = op1Fn 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 791  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 815  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 826  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 872  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.3495  
changed lines
  Added in v.3978

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