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

SCM Repository

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

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

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

revision 4252, Mon Jul 25 03:26:21 2016 UTC revision 4338, Mon Aug 1 19:16:52 2016 UTC
# Line 175  Line 175 
175      def iter (es):      def iter (es):
176          sum = 0          sum = 0
177          for i in es:          for i in es:
178              sum+=i*i              t=i*i
179                #print "t",t
180                sum+=t
181          #print "\nsum",sum          #print "\nsum",sum
182          rtn  = sqrt(sum)          rtn  = sqrt(sum)
183          #print "\nrtn",rtn          #print "\nrtn",rtn
184          return rtn          return rtn
185      if(field.is_Scalar(fld)):      if(field.is_Scalar(fld)):
186          [] = fty.get_shape(ityp)          [] = fty.get_shape(ityp)
187          return exp          #print "scalar exp:",exp
188            t =abs(sqrt(exp*exp))
189            #print "t",t
190            return t
191      elif(field.is_Vector(fld)):      elif(field.is_Vector(fld)):
192          [n] = fty.get_shape(ityp)          [n] = fty.get_shape(ityp)
193          rtn = []          rtn = []
# Line 365  Line 370 
370      exp1 = field.get_data(fld1)      exp1 = field.get_data(fld1)
371      exp2 = field.get_data(fld2)      exp2 = field.get_data(fld2)
372      ityp1 = field.get_ty(fld1)      ityp1 = field.get_ty(fld1)
373      [n, m] = fty.get_shape(ityp1)      if(field.is_Matrix(fld1)):
374      rtn = 0      rtn = 0
375            [n, m] = fty.get_shape(ityp1)
376      for i in range(n):      for i in range(n):
377              for j in range(m):              for j in range(m):
378                  rtn+=exp1[i][j]*exp2[i][j]                  rtn+=exp1[i][j]*exp2[i][j]
379      return rtn      return rtn
380        elif(field.is_Ten3(fld1)):
381            rtn = []
382            [n, m, l] = fty.get_shape(ityp1)
383            for i in range(n):
384                for j in range(m):
385                    for k in range(l):
386                        rtn.append(exp1[i][j][k]*exp2[i][j][k])
387            return rtn
388        else:
389            raise "unsupported double dot"
390    
391    
392    
# Line 412  Line 428 
428      ityp1 = field.get_ty(fld1)      ityp1 = field.get_ty(fld1)
429      exp2 = field.get_data(fld2)      exp2 = field.get_data(fld2)
430      ityp2 = field.get_ty(fld2)      ityp2 = field.get_ty(fld2)
431      rtn=[]      ashape = fty.get_shape(ityp1)
432        bshape = fty.get_shape(ityp2)
433        x= "ashape", ashape, "bshape", bshape
434      #print "exp1",exp1,"ityp1",ityp1.name,"-length",len(exp1)      #print "exp1",exp1,"ityp1",ityp1.name,"-length",len(exp1)
435      #print "exp2",exp2,"ityp2",ityp2.name,"-length",len(exp2)      #print "exp2",exp2,"ityp2",ityp2.name,"-length",len(exp2)
436        rtn = []
437      if(fty.is_Vector(ityp1)):      if(fty.is_Vector(ityp1)):
438          n1= fty.get_vecLength(ityp1)          [n1] = fty.get_shape(ityp1)
439          if(fty.is_Vector(ityp2)):          if(fty.is_Vector(ityp2)):
440              #both vectors              #both vectors
441              n2= fty.get_vecLength(ityp2)              [n2] = fty.get_shape(ityp2)
442              for i in  range(n1):              for i in  range(n1):
443                  tmpI = []                  tmpI = []
444                  for j in range(n2):                  for j in range(n2):
# Line 441  Line 459 
459      elif(fty.is_Matrix(ityp1)):      elif(fty.is_Matrix(ityp1)):
460          [n1,n2] = fty.get_shape(ityp1)          [n1,n2] = fty.get_shape(ityp1)
461          if(fty.is_Vector(ityp2)):          if(fty.is_Vector(ityp2)):
462              n3= fty.get_vecLength(ityp2)              [n3] = fty.get_shape(ityp2)
463              for i in  range(n1):              for i in  range(n1):
464                  tmpI = []                  tmpI = []
465                  for j in range(n2):                  for j in range(n2):
# Line 475  Line 493 
493      ityp1 = field.get_ty(fld1)      ityp1 = field.get_ty(fld1)
494      exp2 = field.get_data(fld2)      exp2 = field.get_data(fld2)
495      ityp2 = field.get_ty(fld2)      ityp2 = field.get_ty(fld2)
496      #print " exp1: ",exp1," exp2: ",exp2      ashape = fty.get_shape(ityp1)
497      # vectors      bshape = fty.get_shape(ityp2)
498        x= "ashape", ashape, "bshape", bshape
499      if(fty.is_Vector(ityp1)):      if(fty.is_Vector(ityp1)):
500          n1 = fty.get_vecLength(ityp1) #vector          [a1] = fty.get_shape(ityp1)
501          if(fty.is_Vector(ityp2)):          if(fty.is_Vector(ityp2)):
502              #length of vetors              #length of vetors
503              rtn=0              rtn=0
504              n2 = fty.get_vecLength(ityp2)              [b1] = fty.get_shape(ityp2)
505              for s in  range(n1):              if(a1!=b1):
506                  curr = exp1[s]*exp2[s]                  raise x
507                  #print (" exp1[s]: ",exp1[s]," exp2[s]: ",exp2[s],"cur",curr)              for s in  range(a1):
508                  rtn += curr                  rtn += exp1[s]*exp2[s]
509              return rtn              return rtn
510          elif(fty.is_Matrix(ityp2)):          elif(fty.is_Matrix(ityp2)):
511              [n2] = fty.drop_last(ityp2)  #matrix              [b1,b2] = fty.get_shape(ityp2)
512              rtn=[]              rtn=[]
513              for i in  range(n2):              if(a1!=b1):
514                    raise x
515                for i in  range(b2):
516                  sumrtn=0                  sumrtn=0
517                  for s in  range(n1):                  for s in  range(a1):
518                      curr = exp1[s]*exp2[s][i]                      sumrtn +=  exp1[s]*exp2[s][i]
                     sumrtn += curr  
519                  rtn.append(sumrtn)                  rtn.append(sumrtn)
520              return rtn              return rtn
521          elif(fty.is_Ten3(ityp2)):          elif(fty.is_Ten3(ityp2)):
522              [n2,n3] = fty.drop_last(ityp2)              [b1, b2, b3] = fty.get_shape(ityp2)
523              rtn = []              rtn = []
524              for i in  range(n2):              if(a1!=b1):
525                    raise x
526                for i in  range(b2):
527                  tmpJ = []                  tmpJ = []
528                  for j in  range(n3):                  for j in  range(b3):
529                      sumrtn=0                      sumrtn=0
530                      for s in  range(n1):                      for s in  range(a1):
531                          curr = exp1[s]*exp2[s][i][j]                          sumrtn +=  exp1[s]*exp2[s][i][j]
                         sumrtn += curr  
532                      tmpJ.append(sumrtn)                      tmpJ.append(sumrtn)
533                  rtn.append(tmpJ)                  rtn.append(tmpJ)
534              return rtn              return rtn
535          else:          else:
536              raise "inner product is not supported"              raise "inner product is not supported"
537      elif(fty.is_Matrix(ityp1)):      elif(fty.is_Matrix(ityp1)):
538          n2 = fty.get_first_ix(ityp1)  #matrix          [a1,a2] = fty.get_shape(ityp1)
539          if(fty.is_Vector(ityp2)):          if(fty.is_Vector(ityp2)):
540              ns = fty.get_vecLength(ityp2) #vector              [b1] = fty.get_shape(ityp2)
541                if(a2!=b1):
542                    raise x
543              rtn=[]              rtn=[]
544              for i in  range(n2):              for i in  range(a1):
545                  sumrtn=0                  sumrtn=0
546                  for s in  range(ns):                  for s in  range(a2):
547                      curr = exp1[i][s]*exp2[s]                      sumrtn += exp1[i][s]*exp2[s]
                     sumrtn += curr  
548                  rtn.append(sumrtn)                  rtn.append(sumrtn)
549              return rtn              return rtn
550            elif(fty.is_Matrix(ityp2)):
551                [b1,b2] = fty.get_shape(ityp2)
552                rtn=[]
553                if(a2!=b1):
554                    raise x
555                for i in  range(a1):
556                    rtnj = []
557                    for j in  range(b2):
558                        sumrtn=0
559                        for s in  range(a2):
560                            sumrtn += exp1[i][s]*exp2[s][j]
561                        rtnj.append(sumrtn)
562                    rtn.append(rtnj)
563                return rtn
564            elif(fty.is_Ten3(ityp2)):
565                [b1,b2, b3] = fty.get_shape(ityp2)
566                rtn=[]
567                if(a2!=b1):
568                    raise x
569                for i in  range(a1):
570                    rtnj = []
571                    for j in  range(b2):
572                        rtnk = []
573                        for k in range(b3):
574                            sumrtn=0
575                            for s in  range(a2):
576                                sumrtn += exp1[i][s]*exp2[s][j][k]
577                            rtnk.append(sumrtn)
578                        rtnj.append(rtnk)
579                    rtn.append(rtnj)
580                return rtn
581    
582          else:          else:
583              raise "inner product is not supported"              raise "inner product is not supported"
584      elif(fty.is_Ten3(ityp1)):      elif(fty.is_Ten3(ityp1)):
585          [n1,n2] = fty.drop_first(ityp1)          [a1,a2, a3] = ashape
586          if(fty.is_Vector(ityp2)):          if(fty.is_Vector(ityp2)):
587              ns = fty.get_vecLength(ityp2)              [b1] = bshape
588                if(a3!=b1):
589                    raise x
590              rtn=[]              rtn=[]
591              for i in  range(n1):              for i in  range(a1):
592                  tmpI=[]                  tmpI=[]
593                  for j in  range(n2):                  for j in  range(a2):
594                      sumrtn=0                      sumrtn=0
595                      for s in  range(ns):                      for s in  range(a3):
596                          curr = exp1[i][j][s]*exp2[s]                          sumrtn += exp1[i][j][s]*exp2[s]
                         sumrtn += curr  
597                      tmpI.append(sumrtn)                      tmpI.append(sumrtn)
598                  rtn.append(tmpI)                  rtn.append(tmpI)
599              return rtn              return rtn
600            if(fty.is_Matrix(ityp2)):
601                [b1,b2] = bshape
602                if(a3!=b1):
603                    raise x
604                rtn=[]
605                for i in  range(a1):
606                    tmpI=[]
607                    for j in  range(a2):
608                        tmpJ = []
609                        for k in range(b2):
610                            sumrtn=0
611                            for s in  range(a3):
612                                sumrtn += exp1[i][j][s]*exp2[s][k]
613                            tmpJ.append(sumrtn)
614                        tmpI.append(tmpJ)
615                    rtn.append(tmpI)
616                return rtn
617          else:          else:
618              raise "inner product is not supported"              raise "inner product is not supported"
619      else:      else:
# Line 594  Line 666 
666          rtn.append(tmpI)          rtn.append(tmpI)
667      return rtn      return rtn
668    
669    def applyToT3s(vecA, vecB, unary):
670        rtn = []
671        for (a,b) in zip(vecA, vecB):
672            tmpI = []
673            for (i,j) in zip(a,b):
674                tmpJ = []
675                for (u,v) in zip(i,j):
676                    tmpJ.append(unary(u, v))
677                tmpI.append(tmpJ)
678            rtn.append(tmpI)
679        return rtn
680    
681    
682  # ***************************  apply to scalars or vectors ***************************  # ***************************  apply to scalars or vectors ***************************
683  #apply operators to expression  #apply operators to expression
684  # return output types and expression  # return output types and expression
# Line 604  Line 689 
689      exp = field.get_data(fld)      exp = field.get_data(fld)
690      dim = field.get_dim(fld)      dim = field.get_dim(fld)
691      #print fn_name      #print fn_name
692      if(op_probe==fn_name): #probing      if(op_copy==fn_name): #probing
693          return  exp          return  exp
694      elif(op_negation==fn_name): #negation      elif(op_negation==fn_name): #negation
695          return fn_negation(exp)          return fn_negation(exp)
# Line 631  Line 716 
716  # exp: vector  types  # exp: vector  types
717  def applyToExp_U_V(fn_name, fld):  def applyToExp_U_V(fn_name, fld):
718      exp = field.get_data(fld)      exp = field.get_data(fld)
719      if(op_probe==fn_name): #probing      if(op_copy==fn_name): #probing
720          return exp          return exp
721      elif(op_negation==fn_name): #negation      elif(op_negation==fn_name): #negation
722          return applyToVector(exp, fn_negation)          return applyToVector(exp, fn_negation)
# Line 652  Line 737 
737    
738  def applyToExp_U_M(fn_name, fld):  def applyToExp_U_M(fn_name, fld):
739      exp = field.get_data(fld)      exp = field.get_data(fld)
740      if(op_probe==fn_name): #probing      if(op_copy==fn_name): #probing
741          return exp          return exp
742      elif(op_negation==fn_name): #negation      elif(op_negation==fn_name): #negation
743          return applyToM(exp, fn_negation)          return applyToM(exp, fn_negation)
# Line 673  Line 758 
758    
759  def applyToExp_U_T3(fn_name, fld):  def applyToExp_U_T3(fn_name, fld):
760      exp = field.get_data(fld)      exp = field.get_data(fld)
761      if(op_probe==fn_name): #probing      if(op_copy==fn_name): #probing
762          return exp          return exp
763      elif(op_negation==fn_name): #negation      elif(op_negation==fn_name): #negation
764          return applyToT3(exp, fn_negation)          return applyToT3(exp, fn_negation)
# Line 686  Line 771 
771      else:      else:
772          raise Exception("unsupported unary operator:"+ fn_name.name)          raise Exception("unsupported unary operator:"+ fn_name.name)
773    
774    # binary, args do not need to have the same shape
775    def applyToExp_B_rest(e):
776        fn_name=e.opr
777        (fld1,fld2) =  apply.get_binary(e)
778        exp1 = field.get_data(fld1)
779        exp2 = field.get_data(fld2)
780        if(op_outer==fn_name):
781            return fn_outer(fld1, fld2)
782        elif(op_inner==fn_name):
783            return fn_inner(fld1, fld2)
784        elif(op_scale==fn_name): #scaling
785            return fn_scaling(fld1,fld2)
786        else:
787            raise Exception("unsupported unary operator:"+fn_name.name)
788    
789  # binary operator  # binary operator
790  # exp: scalar types  # exp: scalar types
791  def applyToExp_B_S(e):  def applyToExp_B_S(e):
792      fn_name=e.opr      fn_name=e.opr
793    
794      (fld1,fld2) =  apply.get_binary(e)      (fld1,fld2) =  apply.get_binary(e)
795      exp1 = field.get_data(fld1)      exp1 = field.get_data(fld1)
796      exp2 = field.get_data(fld2)      exp2 = field.get_data(fld2)
# Line 707  Line 808 
808      else:      else:
809          raise Exception("unsupported binary operator on scalar fields:"+ fn_name.name)          raise Exception("unsupported binary operator on scalar fields:"+ fn_name.name)
810    
 # 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)  
   
811    
812  # binary operator  # binary operator
813  # args have the same shape  # args have the same shape
814  def applyToExp_B_V(e):  def applyToExp_B_V(e):
815    
816      fn_name=e.opr      fn_name=e.opr
817      (fld1,fld2) =  apply.get_binary(e)      (fld1,fld2) =  apply.get_binary(e)
818      exp1 = field.get_data(fld1)      exp1 = field.get_data(fld1)
# Line 739  Line 826 
826      elif(op_cross==fn_name):      elif(op_cross==fn_name):
827          return fn_cross(fld1, fld2)          return fn_cross(fld1, fld2)
828      else:      else:
829         return applyToExp_B_uneven(e)         return applyToExp_B_rest(e)
830    
831  def applyToExp_B_M(e):  def applyToExp_B_M(e):
832        print "b. m"
833      fn_name=e.opr      fn_name=e.opr
834      (fld1,fld2) =  apply.get_binary(e)      (fld1,fld2) =  apply.get_binary(e)
835      exp1 = field.get_data(fld1)      exp1 = field.get_data(fld1)
# Line 752  Line 840 
840          return  applyToMs(exp1, exp2, fn_subtract)          return  applyToMs(exp1, exp2, fn_subtract)
841      elif(op_modulate==fn_name):#modulate      elif(op_modulate==fn_name):#modulate
842          return applyToMs(exp1,exp2,fn_modulate)          return applyToMs(exp1,exp2,fn_modulate)
     elif(op_doubledot==fn_name):#op_doubledot  
         return fn_doubledot (fld1,fld2)  
843      else:      else:
844          return applyToExp_B_uneven(e)          return applyToExp_B_rest(e)
845    
846    def applyToExp_B_T3(e):
847        print "b. m"
848        fn_name=e.opr
849        (fld1,fld2) =  apply.get_binary(e)
850        exp1 = field.get_data(fld1)
851        exp2 = field.get_data(fld2)
852        if(op_add==fn_name):#addition
853            return applyToT3s(exp1, exp2,  fn_add)
854        elif(op_subtract==fn_name):#subtract
855            return  applyToT3s(exp1, exp2, fn_subtract)
856        elif(op_modulate==fn_name):#modulate
857            return applyToT3s(exp1,exp2,fn_modulate)
858        else:
859            return applyToExp_B_rest(e)
860    
861    
862  # ***************************  unary/binary operators ***************************  # ***************************  unary/binary operators ***************************
# Line 767  Line 868 
868      dim = field.get_dim(fld)      dim = field.get_dim(fld)
869      if(op_norm==fn_name):#norm      if(op_norm==fn_name):#norm
870          return fn_norm(fld, dim)          return fn_norm(fld, dim)
871      if(op_normalize==fn_name):#normalize      elif(op_normalize==fn_name):#normalize
872          x= fn_normalize(fld, dim)          x= fn_normalize(fld, dim)
873          return x          return x
874      elif (field.is_Scalar(fld)): # input is a scalar field      elif (field.is_Scalar(fld)): # input is a scalar field
# Line 785  Line 886 
886      # type is checked elsewhere or does not matter      # type is checked elsewhere or does not matter
887      if(op_division==fn_name): #division      if(op_division==fn_name): #division
888          return fn_division(f, g)          return fn_division(f, g)
889        elif(op_doubledot==fn_name):#op_doubledot
890            return fn_doubledot (f, g)
891        elif(op_outer==fn_name):
892            return fn_outer(f, g)
893        elif(op_inner==fn_name):
894            return fn_inner(f, g)
895        elif(op_scale==fn_name): #scaling
896            return fn_scaling(f,g)
897      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
898          return applyToExp_B_S(e)          return applyToExp_B_S(e)
899      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)):  
             return applyToExp_B_V(e)  
         else: # input is a vector field, _  
900              return applyToExp_B_V(e)              return applyToExp_B_V(e)
901      elif (field.is_Matrix(f)):# input is a matrix field      elif (field.is_Matrix(f) and field.is_Matrix(g)):
         if(field.is_Matrix(g)):  
902              return applyToExp_B_M(e)              return applyToExp_B_M(e)
903        elif (field.is_Ten3(f) and field.is_Ten3(g)):
904            return applyToExp_B_T3(e)
905          else:          else:
906              return  applyToExp_B_V(e)           return applyToExp_B_rest(e)
     else:  
          return applyToExp_B_V(e)  
907    
908  def applyUnaryOnce(oexp_inner,app_inner,app_outer):  def applyUnaryOnce(oexp_inner,app_inner,app_outer):
909      #print "applyUnaryOnce"      #print "applyUnaryOnce"
# Line 882  Line 987 
987    
988  # ***************************  evaluate at positions ***************************  # ***************************  evaluate at positions ***************************
989  #evaluate scalar field exp  #evaluate scalar field exp
990    def eval_d0(pos0, exp):
991        return exp
992    
993    
994  def eval_d1(pos0, exp):  def eval_d1(pos0, exp):
995      #print "eval vec d1"      #print "eval vec d1"
996      #print "exp:",exp      #print "exp:",exp
# Line 1021  Line 1130 
1130    
1131  def probeField(otyp1,pos, ortn):  def probeField(otyp1,pos, ortn):
1132      dim = fty.get_dim(otyp1)      dim = fty.get_dim(otyp1)
1133      #print "output type"+otyp1.name      print "output type"+otyp1.name
1134      if (dim==1):      if (dim==nonefield_dim):
1135            #still need to flatten
1136            rtn = []
1137            if (fty.is_Matrix(otyp1)):
1138                for i in ortn:
1139                    for j in i :
1140                        rtn.append(j)
1141                return [rtn]
1142            elif (fty.is_Ten3(otyp1)):
1143                for i in ortn:
1144                    for j in i :
1145                        for k in  j:
1146                            rtn.append(k)
1147                return [rtn]
1148    
1149            else:
1150                return [ortn]
1151    
1152        elif (dim==1):
1153          def get_k():          def get_k():
1154              if (fty.is_ScalarField(otyp1)): # output is a scalar field              if (fty.is_ScalarField(otyp1)): # output is a scalar field
1155                  #print "s_d1"                  #print "s_d1"

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

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