Home My Page Projects Code Snippets Project Openings diderot

# SCM Repository

[diderot] Diff of /branches/ein16/synth/d2/test_eval.py
 [diderot] / branches / ein16 / synth / d2 / test_eval.py

# Diff of /branches/ein16/synth/d2/test_eval.py

revision 4252, Mon Jul 25 03:26:21 2016 UTC revision 4411, Fri Aug 12 18:28:57 2016 UTC
# Line 147  Line 147
147
148  #evaluate jacob  #evaluate jacob
149  def fn_jacob(fld):  def fn_jacob(fld):
150        #print "inside jacob"
151      exp = field.get_data(fld)      exp = field.get_data(fld)
152      ityp = field.get_ty(fld)      ityp = field.get_ty(fld)
153      dim = field.get_dim(fld)      dim = field.get_dim(fld)
154      #print " exp1: ",exp1," exp2: ",exp2      #print " exp1: ",exp1," exp2: ",exp2
155        shape = fty.get_shape(ityp)
156      # vectors      # vectors
157      n = fty.get_vecLength(ityp) #vector      if(field.is_VectorField (fld)):
158            print "found a vector"
159            [n] = shape #vector
160      if(n!=dim):      if(n!=dim):
161         raise (" type not supported for jacob")         raise (" type not supported for jacob")
162      if(n==2):          if(dim==2):
163          return [[diff(exp[0],x), diff(exp[0],y)],          return [[diff(exp[0],x), diff(exp[0],y)],
164                  [diff(exp[1],x), diff(exp[1],y)]]                  [diff(exp[1],x), diff(exp[1],y)]]
165      elif(n==3):          elif(dim==3):
166          return  [[diff(exp[0],x), diff(exp[0],y), diff(exp[0],z)],          return  [[diff(exp[0],x), diff(exp[0],y), diff(exp[0],z)],
167                   [diff(exp[1],x), diff(exp[1],y), diff(exp[1],z)],                   [diff(exp[1],x), diff(exp[1],y), diff(exp[1],z)],
168                   [diff(exp[2],x), diff(exp[2],y), diff(exp[2],z)]]                   [diff(exp[2],x), diff(exp[2],y), diff(exp[2],z)]]
169      else:      else:
170                raise (" type not supported for jacob")
171        elif(field.is_Matrix (fld)):
172            #print "inside matrix"
173            [n,m] = shape #vector
174            if(n!=dim and n!=m):
175                raise (" type not supported for jacob")
176            elif(dim==2):
177                e_00 = exp[0][0]
178                e_10 = exp[1][0]
179                e_01 = exp[0][1]
180                e_11 = exp[1][1]
181                f_00 = [diff(e_00,x), diff(e_00,y)]
182                f_01 = [diff(e_01,x), diff(e_01,y)]
183                f_10 = [diff(e_10,x), diff(e_10,y)]
184                f_11 = [diff(e_11,x), diff(e_11,y)]
185                return [[f_00,f_01],[f_10,f_11]]
186            elif(dim==3):
187                e_00 = exp[0][0]
188                e_10 = exp[1][0]
189                e_20 = exp[2][0]
190                e_01 = exp[0][1]
191                e_11 = exp[1][1]
192                e_21 = exp[2][1]
193                e_02 = exp[0][2]
194                e_12 = exp[1][2]
195                e_22 = exp[2][2]
196                def diff_d3(e):
197                    return [diff(e,x), diff(e,y), diff(e,z)]
198                f_00 = diff_d3(e_00)
199                f_01 = diff_d3(e_01)
200                f_02 = diff_d3(e_02)
201                f_10 = diff_d3(e_10)
202                f_11 = diff_d3(e_11)
203                f_12 = diff_d3(e_12)
204                f_20 = diff_d3(e_20)
205                f_21 = diff_d3(e_21)
206                f_22 = diff_d3(e_22)
207                return [[f_00,f_01,f_02],[f_10,f_11,f_12],[f_20,f_21,f_22]]
208            else:
209                raise (" type not supported for jacob")
210        else:
211          raise "unsupported type for jacob"          raise "unsupported type for jacob"
212
213  #evaluate norm  #evaluate norm
# Line 175  Line 220
220      def iter (es):      def iter (es):
221          sum = 0          sum = 0
222          for i in es:          for i in es:
223              sum+=i*i              t=i*i
224                #print "t",t
225                sum+=t
226          #print "\nsum",sum          #print "\nsum",sum
227          rtn  = sqrt(sum)          rtn  = sqrt(sum)
228          #print "\nrtn",rtn          #print "\nrtn",rtn
229          return rtn          return rtn
230      if(field.is_Scalar(fld)):      if(field.is_Scalar(fld)):
231          [] = fty.get_shape(ityp)          [] = fty.get_shape(ityp)
232          return exp          #print "scalar exp:",exp
233            t =(sqrt(exp*exp))
234            #print "t",t
235            return t
236      elif(field.is_Vector(fld)):      elif(field.is_Vector(fld)):
237          [n] = fty.get_shape(ityp)          [n] = fty.get_shape(ityp)
238          rtn = []          rtn = []
# Line 365  Line 415
415      exp1 = field.get_data(fld1)      exp1 = field.get_data(fld1)
416      exp2 = field.get_data(fld2)      exp2 = field.get_data(fld2)
417      ityp1 = field.get_ty(fld1)      ityp1 = field.get_ty(fld1)
418      [n, m] = fty.get_shape(ityp1)      if(field.is_Matrix(fld1)):
419      rtn = 0      rtn = 0
420            [n, m] = fty.get_shape(ityp1)
421      for i in range(n):      for i in range(n):
422              for j in range(m):              for j in range(m):
423                  rtn+=exp1[i][j]*exp2[i][j]                  rtn+=exp1[i][j]*exp2[i][j]
424      return rtn      return rtn
425        elif(field.is_Ten3(fld1)):
426            rtn = []
427            [n, m, l] = fty.get_shape(ityp1)
428            for i in range(n):
429                for j in range(m):
430                    for k in range(l):
431                        rtn.append(exp1[i][j][k]*exp2[i][j][k])
432            return rtn
433        else:
434            raise "unsupported double dot"
435
436
437
# Line 405  Line 466
466      else:      else:
467          raise "unsupported trace"          raise "unsupported trace"
468
469    #evaluate det
470    def fn_inverse(fld):
471        exp = field.get_data(fld)
472        ityp = field.get_ty(fld)
473        rtn=[]
474        if(field.is_Matrix(fld)):
475            [n, m] = fty.get_shape(ityp)
476            if (n!=m):
477                raise Exception("matrix is not identitical")
478            a = exp[0][0]
479            d = exp[1][1]
480            c = exp[1][0]
481            b = exp[0][1]
482            if(n==2):
483                denom = a*d-b*c
484                return [[d/denom,-b/denom],[-c/denom, a/denom]]
485            elif(n==3):
486                a = exp[0][0]
487                b = exp[0][1]
488                c = exp[0][2]
489                d = exp[1][0]
490                e = exp[1][1]
491                f = exp[1][2]
492                g = exp[2][0]
493                h = exp[2][1]
494                i = exp[2][2]
495                denom  =  a*(e*i-f*h)-b*(d*i-f*g)+c*(d*h-e*g)
496                num1 = [(e*i - f*h), -(b*i - c*h), (b*f - c*e)]
497                num2 = [-(d*i - f*g), (a*i -c*g), -(a*f - c*d)]
498                num3 = [(d*h - e*g), -(a*h - b*g),(a*e - b*d)]
499                num =[num1,num2,num3]
500
501                rtn = []
502                for i in range(n):
503                    tmp = []
504                    for j in range(n):
505                        tmp.append(num[i][j]/denom)
506                    rtn.append(tmp)
507                return rtn
508            else:
509                raise "unsupported matrix field"
510        else:
511            raise "unsupported trace"
512
513
514
515
516
517  #evaluate outer product  #evaluate outer product
518  def fn_outer(fld1, fld2):  def fn_outer(fld1, fld2):
# Line 412  Line 520
520      ityp1 = field.get_ty(fld1)      ityp1 = field.get_ty(fld1)
521      exp2 = field.get_data(fld2)      exp2 = field.get_data(fld2)
522      ityp2 = field.get_ty(fld2)      ityp2 = field.get_ty(fld2)
523      rtn=[]      ashape = fty.get_shape(ityp1)
524        bshape = fty.get_shape(ityp2)
525        x= "ashape", ashape, "bshape", bshape
526      #print "exp1",exp1,"ityp1",ityp1.name,"-length",len(exp1)      #print "exp1",exp1,"ityp1",ityp1.name,"-length",len(exp1)
527      #print "exp2",exp2,"ityp2",ityp2.name,"-length",len(exp2)      #print "exp2",exp2,"ityp2",ityp2.name,"-length",len(exp2)
528        rtn = []
529      if(fty.is_Vector(ityp1)):      if(fty.is_Vector(ityp1)):
530          n1= fty.get_vecLength(ityp1)          [n1] = fty.get_shape(ityp1)
531          if(fty.is_Vector(ityp2)):          if(fty.is_Vector(ityp2)):
532              #both vectors              #both vectors
533              n2= fty.get_vecLength(ityp2)              [n2] = fty.get_shape(ityp2)
534              for i in  range(n1):              for i in  range(n1):
535                  tmpI = []                  tmpI = []
536                  for j in range(n2):                  for j in range(n2):
# Line 441  Line 551
551      elif(fty.is_Matrix(ityp1)):      elif(fty.is_Matrix(ityp1)):
552          [n1,n2] = fty.get_shape(ityp1)          [n1,n2] = fty.get_shape(ityp1)
553          if(fty.is_Vector(ityp2)):          if(fty.is_Vector(ityp2)):
554              n3= fty.get_vecLength(ityp2)              [n3] = fty.get_shape(ityp2)
555              for i in  range(n1):              for i in  range(n1):
556                  tmpI = []                  tmpI = []
557                  for j in range(n2):                  for j in range(n2):
# Line 475  Line 585
585      ityp1 = field.get_ty(fld1)      ityp1 = field.get_ty(fld1)
586      exp2 = field.get_data(fld2)      exp2 = field.get_data(fld2)
587      ityp2 = field.get_ty(fld2)      ityp2 = field.get_ty(fld2)
588      #print " exp1: ",exp1," exp2: ",exp2      ashape = fty.get_shape(ityp1)
589      # vectors      bshape = fty.get_shape(ityp2)
590        x= "ashape", ashape, "bshape", bshape
591      if(fty.is_Vector(ityp1)):      if(fty.is_Vector(ityp1)):
592          n1 = fty.get_vecLength(ityp1) #vector          [a1] = fty.get_shape(ityp1)
593          if(fty.is_Vector(ityp2)):          if(fty.is_Vector(ityp2)):
594              #length of vetors              #length of vetors
595              rtn=0              rtn=0
596              n2 = fty.get_vecLength(ityp2)              [b1] = fty.get_shape(ityp2)
597              for s in  range(n1):              if(a1!=b1):
598                  curr = exp1[s]*exp2[s]                  raise x
599                  #print (" exp1[s]: ",exp1[s]," exp2[s]: ",exp2[s],"cur",curr)              for s in  range(a1):
600                  rtn += curr                  rtn += exp1[s]*exp2[s]
601              return rtn              return rtn
602          elif(fty.is_Matrix(ityp2)):          elif(fty.is_Matrix(ityp2)):
603              [n2] = fty.drop_last(ityp2)  #matrix              [b1,b2] = fty.get_shape(ityp2)
604              rtn=[]              rtn=[]
605              for i in  range(n2):              if(a1!=b1):
606                    raise x
607                for i in  range(b2):
608                  sumrtn=0                  sumrtn=0
609                  for s in  range(n1):                  for s in  range(a1):
610                      curr = exp1[s]*exp2[s][i]                      sumrtn +=  exp1[s]*exp2[s][i]
sumrtn += curr
611                  rtn.append(sumrtn)                  rtn.append(sumrtn)
612              return rtn              return rtn
613          elif(fty.is_Ten3(ityp2)):          elif(fty.is_Ten3(ityp2)):
614              [n2,n3] = fty.drop_last(ityp2)              [b1, b2, b3] = fty.get_shape(ityp2)
615              rtn = []              rtn = []
616              for i in  range(n2):              if(a1!=b1):
617                    raise x
618                for i in  range(b2):
619                  tmpJ = []                  tmpJ = []
620                  for j in  range(n3):                  for j in  range(b3):
621                      sumrtn=0                      sumrtn=0
622                      for s in  range(n1):                      for s in  range(a1):
623                          curr = exp1[s]*exp2[s][i][j]                          sumrtn +=  exp1[s]*exp2[s][i][j]
sumrtn += curr
624                      tmpJ.append(sumrtn)                      tmpJ.append(sumrtn)
625                  rtn.append(tmpJ)                  rtn.append(tmpJ)
626              return rtn              return rtn
627          else:          else:
628              raise "inner product is not supported"              raise "inner product is not supported"
629      elif(fty.is_Matrix(ityp1)):      elif(fty.is_Matrix(ityp1)):
630          n2 = fty.get_first_ix(ityp1)  #matrix          [a1,a2] = fty.get_shape(ityp1)
631          if(fty.is_Vector(ityp2)):          if(fty.is_Vector(ityp2)):
632              ns = fty.get_vecLength(ityp2) #vector              [b1] = fty.get_shape(ityp2)
633                if(a2!=b1):
634                    raise x
635              rtn=[]              rtn=[]
636              for i in  range(n2):              for i in  range(a1):
637                  sumrtn=0                  sumrtn=0
638                  for s in  range(ns):                  for s in  range(a2):
639                      curr = exp1[i][s]*exp2[s]                      sumrtn += exp1[i][s]*exp2[s]
sumrtn += curr
640                  rtn.append(sumrtn)                  rtn.append(sumrtn)
641              return rtn              return rtn
642            elif(fty.is_Matrix(ityp2)):
643                [b1,b2] = fty.get_shape(ityp2)
644                rtn=[]
645                if(a2!=b1):
646                    raise x
647                for i in  range(a1):
648                    rtnj = []
649                    for j in  range(b2):
650                        sumrtn=0
651                        for s in  range(a2):
652                            sumrtn += exp1[i][s]*exp2[s][j]
653                        rtnj.append(sumrtn)
654                    rtn.append(rtnj)
655                return rtn
656            elif(fty.is_Ten3(ityp2)):
657                [b1,b2, b3] = fty.get_shape(ityp2)
658                rtn=[]
659                if(a2!=b1):
660                    raise x
661                for i in  range(a1):
662                    rtnj = []
663                    for j in  range(b2):
664                        rtnk = []
665                        for k in range(b3):
666                            sumrtn=0
667                            for s in  range(a2):
668                                sumrtn += exp1[i][s]*exp2[s][j][k]
669                            rtnk.append(sumrtn)
670                        rtnj.append(rtnk)
671                    rtn.append(rtnj)
672                return rtn
673
674          else:          else:
675              raise "inner product is not supported"              raise "inner product is not supported"
676      elif(fty.is_Ten3(ityp1)):      elif(fty.is_Ten3(ityp1)):
677          [n1,n2] = fty.drop_first(ityp1)          [a1,a2, a3] = ashape
678          if(fty.is_Vector(ityp2)):          if(fty.is_Vector(ityp2)):
679              ns = fty.get_vecLength(ityp2)              [b1] = bshape
680                if(a3!=b1):
681                    raise x
682              rtn=[]              rtn=[]
683              for i in  range(n1):              for i in  range(a1):
684                  tmpI=[]                  tmpI=[]
685                  for j in  range(n2):                  for j in  range(a2):
686                      sumrtn=0                      sumrtn=0
687                      for s in  range(ns):                      for s in  range(a3):
688                          curr = exp1[i][j][s]*exp2[s]                          sumrtn += exp1[i][j][s]*exp2[s]
sumrtn += curr
689                      tmpI.append(sumrtn)                      tmpI.append(sumrtn)
690                  rtn.append(tmpI)                  rtn.append(tmpI)
691              return rtn              return rtn
692            if(fty.is_Matrix(ityp2)):
693                [b1,b2] = bshape
694                if(a3!=b1):
695                    raise x
696                rtn=[]
697                for i in  range(a1):
698                    tmpI=[]
699                    for j in  range(a2):
700                        tmpJ = []
701                        for k in range(b2):
702                            sumrtn=0
703                            for s in  range(a3):
704                                sumrtn += exp1[i][j][s]*exp2[s][k]
705                            tmpJ.append(sumrtn)
706                        tmpI.append(tmpJ)
707                    rtn.append(tmpI)
708                return rtn
709          else:          else:
710              raise "inner product is not supported"              raise "inner product is not supported"
711      else:      else:
# Line 594  Line 758
758          rtn.append(tmpI)          rtn.append(tmpI)
759      return rtn      return rtn
760
761    def applyToT3s(vecA, vecB, unary):
762        rtn = []
763        for (a,b) in zip(vecA, vecB):
764            tmpI = []
765            for (i,j) in zip(a,b):
766                tmpJ = []
767                for (u,v) in zip(i,j):
768                    tmpJ.append(unary(u, v))
769                tmpI.append(tmpJ)
770            rtn.append(tmpI)
771        return rtn
772
773
774  # ***************************  apply to scalars or vectors ***************************  # ***************************  apply to scalars or vectors ***************************
775  #apply operators to expression  #apply operators to expression
776  # return output types and expression  # return output types and expression
# Line 604  Line 781
781      exp = field.get_data(fld)      exp = field.get_data(fld)
782      dim = field.get_dim(fld)      dim = field.get_dim(fld)
783      #print fn_name      #print fn_name
784      if(op_probe==fn_name): #probing      if(op_copy==fn_name): #probing
785          return  exp          return  exp
786      elif(op_negation==fn_name): #negation      elif(op_negation==fn_name): #negation
787          return fn_negation(exp)          return fn_negation(exp)
# Line 631  Line 808
808  # exp: vector  types  # exp: vector  types
809  def applyToExp_U_V(fn_name, fld):  def applyToExp_U_V(fn_name, fld):
810      exp = field.get_data(fld)      exp = field.get_data(fld)
811      if(op_probe==fn_name): #probing      if(op_copy==fn_name): #probing
812          return exp          return exp
813      elif(op_negation==fn_name): #negation      elif(op_negation==fn_name): #negation
814          return applyToVector(exp, fn_negation)          return applyToVector(exp, fn_negation)
# Line 652  Line 829
829
830  def applyToExp_U_M(fn_name, fld):  def applyToExp_U_M(fn_name, fld):
831      exp = field.get_data(fld)      exp = field.get_data(fld)
832      if(op_probe==fn_name): #probing      if(op_copy==fn_name): #probing
833          return exp          return exp
834      elif(op_negation==fn_name): #negation      elif(op_negation==fn_name): #negation
835          return applyToM(exp, fn_negation)          return applyToM(exp, fn_negation)
836      elif(op_jacob==fn_name): #jacob      elif(op_jacob==fn_name): #jacob
837          return fn_jacob(fld)          #print "app u-m"
838            x = fn_jacob(fld)
839            #print "x", x
840            return x
841      elif(op_slicem0==fn_name) :      elif(op_slicem0==fn_name) :
842          return fn_slicem0(fld)          return fn_slicem0(fld)
843      elif(op_slicem1==fn_name):      elif(op_slicem1==fn_name):
# Line 668  Line 848
848          return fn_transpose(fld)          return fn_transpose(fld)
849      elif(op_det==fn_name):      elif(op_det==fn_name):
850          return fn_det(fld)          return fn_det(fld)
851        elif(op_inverse == fn_name):
852            return fn_inverse(fld)
853      else:      else:
854          raise Exception("unsupported unary operator:"+ fn_name.name)          raise Exception("unsupported unary operator:"+ fn_name.name)
855
856  def applyToExp_U_T3(fn_name, fld):  def applyToExp_U_T3(fn_name, fld):
857      exp = field.get_data(fld)      exp = field.get_data(fld)
858      if(op_probe==fn_name): #probing      if(op_copy==fn_name): #probing
859          return exp          return exp
860      elif(op_negation==fn_name): #negation      elif(op_negation==fn_name): #negation
861          return applyToT3(exp, fn_negation)          return applyToT3(exp, fn_negation)
# Line 686  Line 868
868      else:      else:
869          raise Exception("unsupported unary operator:"+ fn_name.name)          raise Exception("unsupported unary operator:"+ fn_name.name)
870
871    # binary, args do not need to have the same shape
872    def applyToExp_B_rest(e):
873        fn_name=e.opr
874        (fld1,fld2) =  apply.get_binary(e)
875        exp1 = field.get_data(fld1)
876        exp2 = field.get_data(fld2)
877        if(op_outer==fn_name):
878            return fn_outer(fld1, fld2)
879        elif(op_inner==fn_name):
880            return fn_inner(fld1, fld2)
881        elif(op_scale==fn_name): #scaling
882            return fn_scaling(fld1,fld2)
883        else:
884            raise Exception("unsupported unary operator:"+fn_name.name)
885
886  # binary operator  # binary operator
887  # exp: scalar types  # exp: scalar types
888  def applyToExp_B_S(e):  def applyToExp_B_S(e):
889      fn_name=e.opr      fn_name=e.opr
890
891      (fld1,fld2) =  apply.get_binary(e)      (fld1,fld2) =  apply.get_binary(e)
892      exp1 = field.get_data(fld1)      exp1 = field.get_data(fld1)
893      exp2 = field.get_data(fld2)      exp2 = field.get_data(fld2)
# Line 707  Line 905
905      else:      else:
906          raise Exception("unsupported binary operator on scalar fields:"+ fn_name.name)          raise Exception("unsupported binary operator on scalar fields:"+ fn_name.name)
907
# binary, args do not need to have the same shape
def applyToExp_B_uneven(e):
fn_name=e.opr
(fld1,fld2) =  apply.get_binary(e)
exp1 = field.get_data(fld1)
exp2 = field.get_data(fld2)
if(op_outer==fn_name):
return fn_outer(fld1, fld2)
elif(op_inner==fn_name):
return fn_inner(fld1, fld2)
elif(op_scale==fn_name): #scaling
return fn_scaling(fld1,fld2)
else:
raise Exception("unsupported unary operator:",op_name)

908
909  # binary operator  # binary operator
910  # args have the same shape  # args have the same shape
911  def applyToExp_B_V(e):  def applyToExp_B_V(e):
912
913      fn_name=e.opr      fn_name=e.opr
914      (fld1,fld2) =  apply.get_binary(e)      (fld1,fld2) =  apply.get_binary(e)
915      exp1 = field.get_data(fld1)      exp1 = field.get_data(fld1)
# Line 739  Line 923
923      elif(op_cross==fn_name):      elif(op_cross==fn_name):
924          return fn_cross(fld1, fld2)          return fn_cross(fld1, fld2)
925      else:      else:
926         return applyToExp_B_uneven(e)         return applyToExp_B_rest(e)
927
928  def applyToExp_B_M(e):  def applyToExp_B_M(e):
929        print "b. m"
930      fn_name=e.opr      fn_name=e.opr
931      (fld1,fld2) =  apply.get_binary(e)      (fld1,fld2) =  apply.get_binary(e)
932      exp1 = field.get_data(fld1)      exp1 = field.get_data(fld1)
# Line 752  Line 937
937          return  applyToMs(exp1, exp2, fn_subtract)          return  applyToMs(exp1, exp2, fn_subtract)
938      elif(op_modulate==fn_name):#modulate      elif(op_modulate==fn_name):#modulate
939          return applyToMs(exp1,exp2,fn_modulate)          return applyToMs(exp1,exp2,fn_modulate)
elif(op_doubledot==fn_name):#op_doubledot
return fn_doubledot (fld1,fld2)
940      else:      else:
941          return applyToExp_B_uneven(e)          return applyToExp_B_rest(e)
942
943    def applyToExp_B_T3(e):
944        print "b. m"
945        fn_name=e.opr
946        (fld1,fld2) =  apply.get_binary(e)
947        exp1 = field.get_data(fld1)
948        exp2 = field.get_data(fld2)
951        elif(op_subtract==fn_name):#subtract
952            return  applyToT3s(exp1, exp2, fn_subtract)
953        elif(op_modulate==fn_name):#modulate
954            return applyToT3s(exp1,exp2,fn_modulate)
955        else:
956            return applyToExp_B_rest(e)
957
958
959  # ***************************  unary/binary operators ***************************  # ***************************  unary/binary operators ***************************
# Line 767  Line 965
965      dim = field.get_dim(fld)      dim = field.get_dim(fld)
966      if(op_norm==fn_name):#norm      if(op_norm==fn_name):#norm
967          return fn_norm(fld, dim)          return fn_norm(fld, dim)
968      if(op_normalize==fn_name):#normalize      elif(op_normalize==fn_name):#normalize
969          x= fn_normalize(fld, dim)          x= fn_normalize(fld, dim)
970          return x          return x
971      elif (field.is_Scalar(fld)): # input is a scalar field      elif (field.is_Scalar(fld)): # input is a scalar field
# Line 785  Line 983
983      # type is checked elsewhere or does not matter      # type is checked elsewhere or does not matter
984      if(op_division==fn_name): #division      if(op_division==fn_name): #division
985          return fn_division(f, g)          return fn_division(f, g)
986        elif(op_doubledot==fn_name):#op_doubledot
987            return fn_doubledot (f, g)
988        elif(op_outer==fn_name):
989            return fn_outer(f, g)
990        elif(op_inner==fn_name):
991            return fn_inner(f, g)
992        elif(op_scale==fn_name): #scaling
993            return fn_scaling(f,g)
994      elif (field.is_Scalar(f) and field.is_Scalar(g)): # input is a scalar field      elif (field.is_Scalar(f) and field.is_Scalar(g)): # input is a scalar field
995          return applyToExp_B_S(e)          return applyToExp_B_S(e)
996      elif (field.is_Vector(f)):# input is a vector field      elif (field.is_Vector(f) and field.is_Vector(g)):
if(field.is_Vector(g)):
997              return applyToExp_B_V(e)              return applyToExp_B_V(e)
998          else: # input is a vector field, _      elif (field.is_Matrix(f) and field.is_Matrix(g)):
return applyToExp_B_V(e)
elif (field.is_Matrix(f)):# input is a matrix field
if(field.is_Matrix(g)):
999              return applyToExp_B_M(e)              return applyToExp_B_M(e)
1000        elif (field.is_Ten3(f) and field.is_Ten3(g)):
1001            return applyToExp_B_T3(e)
1002          else:          else:
1003              return  applyToExp_B_V(e)           return applyToExp_B_rest(e)
else:
return applyToExp_B_V(e)
1004
1005  def applyUnaryOnce(oexp_inner,app_inner,app_outer):  def applyUnaryOnce(oexp_inner,app_inner,app_outer):
1006      #print "applyUnaryOnce"      #print "applyUnaryOnce"
# Line 882  Line 1084
1084
1085  # ***************************  evaluate at positions ***************************  # ***************************  evaluate at positions ***************************
1086  #evaluate scalar field exp  #evaluate scalar field exp
1087    def eval_d0(pos0, exp):
1088        return exp
1089
1090
1091  def eval_d1(pos0, exp):  def eval_d1(pos0, exp):
1092      #print "eval vec d1"      #print "eval vec d1"
1093      #print "exp:",exp      #print "exp:",exp
# Line 981  Line 1187
1187  def eval_ten3_d3(pos0, pos1, pos2,ten3):  def eval_ten3_d3(pos0, pos1, pos2,ten3):
1188      rtn = []      rtn = []
1189      for i in ten3:      for i in ten3:
1190
1191          for j in i:          for j in i:
1192
1193              for v in j:              for v in j:
1194
1195                  rtn.append(eval_d3(pos0, pos1, pos2, v))                  rtn.append(eval_d3(pos0, pos1, pos2, v))
1196      return rtn      return rtn
1197
# Line 1022  Line 1231
1231  def probeField(otyp1,pos, ortn):  def probeField(otyp1,pos, ortn):
1232      dim = fty.get_dim(otyp1)      dim = fty.get_dim(otyp1)
1233      #print "output type"+otyp1.name      #print "output type"+otyp1.name
1234      if (dim==1):      #print "inside probe field ortn", ortn
1235        if (dim==nonefield_dim):
1236            #still need to flatten
1237            rtn = []
1238            if (fty.is_Matrix(otyp1)):
1239                for i in ortn:
1240                    for j in i :
1241                        rtn.append(j)
1242                return [rtn]
1243            elif (fty.is_Ten3(otyp1)):
1244                for i in ortn:
1245                    for j in i :
1246                        for k in  j:
1247                            rtn.append(k)
1248                return [rtn]
1249
1250            else:
1251                return [ortn]
1252
1253        elif (dim==1):
1254          def get_k():          def get_k():
1255              if (fty.is_ScalarField(otyp1)): # output is a scalar field              if (fty.is_ScalarField(otyp1)): # output is a scalar field
1256                  #print "s_d1"                  #print "s_d1"

Legend:
 Removed from v.4252 changed lines Added in v.4411