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 4329, Sun Jul 31 20:51:22 2016 UTC
# Line 182  Line 182 
182          return rtn          return rtn
183      if(field.is_Scalar(fld)):      if(field.is_Scalar(fld)):
184          [] = fty.get_shape(ityp)          [] = fty.get_shape(ityp)
185          return exp          return abs(exp)
186      elif(field.is_Vector(fld)):      elif(field.is_Vector(fld)):
187          [n] = fty.get_shape(ityp)          [n] = fty.get_shape(ityp)
188          rtn = []          rtn = []
# Line 365  Line 365 
365      exp1 = field.get_data(fld1)      exp1 = field.get_data(fld1)
366      exp2 = field.get_data(fld2)      exp2 = field.get_data(fld2)
367      ityp1 = field.get_ty(fld1)      ityp1 = field.get_ty(fld1)
368      [n, m] = fty.get_shape(ityp1)      if(field.is_Matrix(fld1)):
369      rtn = 0      rtn = 0
370            [n, m] = fty.get_shape(ityp1)
371      for i in range(n):      for i in range(n):
372              for j in range(m):              for j in range(m):
373                  rtn+=exp1[i][j]*exp2[i][j]                  rtn+=exp1[i][j]*exp2[i][j]
374      return rtn      return rtn
375        elif(field.is_Ten3(fld1)):
376            rtn = []
377            [n, m, l] = fty.get_shape(ityp1)
378            for i in range(n):
379                for j in range(m):
380                    for k in range(l):
381                        rtn.append(exp1[i][j][k]*exp2[i][j][k])
382            return rtn
383        else:
384            raise "unsupported double dot"
385    
386    
387    
# Line 412  Line 423 
423      ityp1 = field.get_ty(fld1)      ityp1 = field.get_ty(fld1)
424      exp2 = field.get_data(fld2)      exp2 = field.get_data(fld2)
425      ityp2 = field.get_ty(fld2)      ityp2 = field.get_ty(fld2)
426      rtn=[]      ashape = fty.get_shape(ityp1)
427        bshape = fty.get_shape(ityp2)
428        x= "ashape", ashape, "bshape", bshape
429      #print "exp1",exp1,"ityp1",ityp1.name,"-length",len(exp1)      #print "exp1",exp1,"ityp1",ityp1.name,"-length",len(exp1)
430      #print "exp2",exp2,"ityp2",ityp2.name,"-length",len(exp2)      #print "exp2",exp2,"ityp2",ityp2.name,"-length",len(exp2)
431        rtn = []
432      if(fty.is_Vector(ityp1)):      if(fty.is_Vector(ityp1)):
433          n1= fty.get_vecLength(ityp1)          [n1] = fty.get_shape(ityp1)
434          if(fty.is_Vector(ityp2)):          if(fty.is_Vector(ityp2)):
435              #both vectors              #both vectors
436              n2= fty.get_vecLength(ityp2)              [n2] = fty.get_shape(ityp2)
437              for i in  range(n1):              for i in  range(n1):
438                  tmpI = []                  tmpI = []
439                  for j in range(n2):                  for j in range(n2):
# Line 441  Line 454 
454      elif(fty.is_Matrix(ityp1)):      elif(fty.is_Matrix(ityp1)):
455          [n1,n2] = fty.get_shape(ityp1)          [n1,n2] = fty.get_shape(ityp1)
456          if(fty.is_Vector(ityp2)):          if(fty.is_Vector(ityp2)):
457              n3= fty.get_vecLength(ityp2)              [n3] = fty.get_shape(ityp2)
458              for i in  range(n1):              for i in  range(n1):
459                  tmpI = []                  tmpI = []
460                  for j in range(n2):                  for j in range(n2):
# Line 475  Line 488 
488      ityp1 = field.get_ty(fld1)      ityp1 = field.get_ty(fld1)
489      exp2 = field.get_data(fld2)      exp2 = field.get_data(fld2)
490      ityp2 = field.get_ty(fld2)      ityp2 = field.get_ty(fld2)
491      #print " exp1: ",exp1," exp2: ",exp2      ashape = fty.get_shape(ityp1)
492      # vectors      bshape = fty.get_shape(ityp2)
493        x= "ashape", ashape, "bshape", bshape
494      if(fty.is_Vector(ityp1)):      if(fty.is_Vector(ityp1)):
495          n1 = fty.get_vecLength(ityp1) #vector          [a1] = fty.get_shape(ityp1)
496          if(fty.is_Vector(ityp2)):          if(fty.is_Vector(ityp2)):
497              #length of vetors              #length of vetors
498              rtn=0              rtn=0
499              n2 = fty.get_vecLength(ityp2)              [b1] = fty.get_shape(ityp2)
500              for s in  range(n1):              if(a1!=b1):
501                  curr = exp1[s]*exp2[s]                  raise x
502                  #print (" exp1[s]: ",exp1[s]," exp2[s]: ",exp2[s],"cur",curr)              for s in  range(a1):
503                  rtn += curr                  rtn += exp1[s]*exp2[s]
504              return rtn              return rtn
505          elif(fty.is_Matrix(ityp2)):          elif(fty.is_Matrix(ityp2)):
506              [n2] = fty.drop_last(ityp2)  #matrix              [b1,b2] = fty.get_shape(ityp2)
507              rtn=[]              rtn=[]
508              for i in  range(n2):              if(a1!=b1):
509                    raise x
510                for i in  range(b2):
511                  sumrtn=0                  sumrtn=0
512                  for s in  range(n1):                  for s in  range(a1):
513                      curr = exp1[s]*exp2[s][i]                      sumrtn +=  exp1[s]*exp2[s][i]
                     sumrtn += curr  
514                  rtn.append(sumrtn)                  rtn.append(sumrtn)
515              return rtn              return rtn
516          elif(fty.is_Ten3(ityp2)):          elif(fty.is_Ten3(ityp2)):
517              [n2,n3] = fty.drop_last(ityp2)              [b1, b2, b3] = fty.get_shape(ityp2)
518              rtn = []              rtn = []
519              for i in  range(n2):              if(a1!=b1):
520                    raise x
521                for i in  range(b2):
522                  tmpJ = []                  tmpJ = []
523                  for j in  range(n3):                  for j in  range(b3):
524                      sumrtn=0                      sumrtn=0
525                      for s in  range(n1):                      for s in  range(a1):
526                          curr = exp1[s]*exp2[s][i][j]                          sumrtn +=  exp1[s]*exp2[s][i][j]
                         sumrtn += curr  
527                      tmpJ.append(sumrtn)                      tmpJ.append(sumrtn)
528                  rtn.append(tmpJ)                  rtn.append(tmpJ)
529              return rtn              return rtn
530          else:          else:
531              raise "inner product is not supported"              raise "inner product is not supported"
532      elif(fty.is_Matrix(ityp1)):      elif(fty.is_Matrix(ityp1)):
533          n2 = fty.get_first_ix(ityp1)  #matrix          [a1,a2] = fty.get_shape(ityp1)
534          if(fty.is_Vector(ityp2)):          if(fty.is_Vector(ityp2)):
535              ns = fty.get_vecLength(ityp2) #vector              [b1] = fty.get_shape(ityp2)
536                if(a2!=b1):
537                    raise x
538              rtn=[]              rtn=[]
539              for i in  range(n2):              for i in  range(a1):
540                  sumrtn=0                  sumrtn=0
541                  for s in  range(ns):                  for s in  range(a2):
542                      curr = exp1[i][s]*exp2[s]                      sumrtn += exp1[i][s]*exp2[s]
                     sumrtn += curr  
543                  rtn.append(sumrtn)                  rtn.append(sumrtn)
544              return rtn              return rtn
545            elif(fty.is_Matrix(ityp2)):
546                [b1,b2] = fty.get_shape(ityp2)
547                rtn=[]
548                if(a2!=b1):
549                    raise x
550                for i in  range(a1):
551                    rtnj = []
552                    for j in  range(b2):
553                        sumrtn=0
554                        for s in  range(a2):
555                            sumrtn += exp1[i][s]*exp2[s][j]
556                        rtnj.append(sumrtn)
557                    rtn.append(rtnj)
558                return rtn
559            elif(fty.is_Ten3(ityp2)):
560                [b1,b2, b3] = fty.get_shape(ityp2)
561                rtn=[]
562                if(a2!=b1):
563                    raise x
564                for i in  range(a1):
565                    rtnj = []
566                    for j in  range(b2):
567                        rtnk = []
568                        for k in range(b3):
569                            sumrtn=0
570                            for s in  range(a2):
571                                sumrtn += exp1[i][s]*exp2[s][j][k]
572                            rtnk.append(sumrtn)
573                        rtnj.append(rtnk)
574                    rtn.append(rtnj)
575                return rtn
576    
577          else:          else:
578              raise "inner product is not supported"              raise "inner product is not supported"
579      elif(fty.is_Ten3(ityp1)):      elif(fty.is_Ten3(ityp1)):
580          [n1,n2] = fty.drop_first(ityp1)          [a1,a2, a3] = ashape
581          if(fty.is_Vector(ityp2)):          if(fty.is_Vector(ityp2)):
582              ns = fty.get_vecLength(ityp2)              [b1] = bshape
583                if(a3!=b1):
584                    raise x
585              rtn=[]              rtn=[]
586              for i in  range(n1):              for i in  range(a1):
587                  tmpI=[]                  tmpI=[]
588                  for j in  range(n2):                  for j in  range(a2):
589                      sumrtn=0                      sumrtn=0
590                      for s in  range(ns):                      for s in  range(a3):
591                          curr = exp1[i][j][s]*exp2[s]                          sumrtn += exp1[i][j][s]*exp2[s]
                         sumrtn += curr  
592                      tmpI.append(sumrtn)                      tmpI.append(sumrtn)
593                  rtn.append(tmpI)                  rtn.append(tmpI)
594              return rtn              return rtn
595            if(fty.is_Matrix(ityp2)):
596                [b1,b2] = bshape
597                if(a3!=b1):
598                    raise x
599                rtn=[]
600                for i in  range(a1):
601                    tmpI=[]
602                    for j in  range(a2):
603                        tmpJ = []
604                        for k in range(b2):
605                            sumrtn=0
606                            for s in  range(a3):
607                                sumrtn += exp1[i][j][s]*exp2[s][k]
608                            tmpJ.append(sumrtn)
609                        tmpI.append(tmpJ)
610                    rtn.append(tmpI)
611                return rtn
612          else:          else:
613              raise "inner product is not supported"              raise "inner product is not supported"
614      else:      else:
# Line 594  Line 661 
661          rtn.append(tmpI)          rtn.append(tmpI)
662      return rtn      return rtn
663    
664    def applyToT3s(vecA, vecB, unary):
665        rtn = []
666        for (a,b) in zip(vecA, vecB):
667            tmpI = []
668            for (i,j) in zip(a,b):
669                tmpJ = []
670                for (u,v) in zip(i,j):
671                    tmpJ.append(unary(u, v))
672                tmpI.append(tmpJ)
673            rtn.append(tmpI)
674        return rtn
675    
676    
677  # ***************************  apply to scalars or vectors ***************************  # ***************************  apply to scalars or vectors ***************************
678  #apply operators to expression  #apply operators to expression
679  # return output types and expression  # return output types and expression
# Line 686  Line 766 
766      else:      else:
767          raise Exception("unsupported unary operator:"+ fn_name.name)          raise Exception("unsupported unary operator:"+ fn_name.name)
768    
769    # binary, args do not need to have the same shape
770    def applyToExp_B_rest(e):
771        fn_name=e.opr
772        (fld1,fld2) =  apply.get_binary(e)
773        exp1 = field.get_data(fld1)
774        exp2 = field.get_data(fld2)
775        if(op_outer==fn_name):
776            return fn_outer(fld1, fld2)
777        elif(op_inner==fn_name):
778            return fn_inner(fld1, fld2)
779        elif(op_scale==fn_name): #scaling
780            return fn_scaling(fld1,fld2)
781        else:
782            raise Exception("unsupported unary operator:"+fn_name.name)
783    
784  # binary operator  # binary operator
785  # exp: scalar types  # exp: scalar types
786  def applyToExp_B_S(e):  def applyToExp_B_S(e):
787      fn_name=e.opr      fn_name=e.opr
788    
789      (fld1,fld2) =  apply.get_binary(e)      (fld1,fld2) =  apply.get_binary(e)
790      exp1 = field.get_data(fld1)      exp1 = field.get_data(fld1)
791      exp2 = field.get_data(fld2)      exp2 = field.get_data(fld2)
# Line 707  Line 803 
803      else:      else:
804          raise Exception("unsupported binary operator on scalar fields:"+ fn_name.name)          raise Exception("unsupported binary operator on scalar fields:"+ fn_name.name)
805    
 # 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)  
   
806    
807  # binary operator  # binary operator
808  # args have the same shape  # args have the same shape
809  def applyToExp_B_V(e):  def applyToExp_B_V(e):
810    
811      fn_name=e.opr      fn_name=e.opr
812      (fld1,fld2) =  apply.get_binary(e)      (fld1,fld2) =  apply.get_binary(e)
813      exp1 = field.get_data(fld1)      exp1 = field.get_data(fld1)
# Line 739  Line 821 
821      elif(op_cross==fn_name):      elif(op_cross==fn_name):
822          return fn_cross(fld1, fld2)          return fn_cross(fld1, fld2)
823      else:      else:
824         return applyToExp_B_uneven(e)         return applyToExp_B_rest(e)
825    
826  def applyToExp_B_M(e):  def applyToExp_B_M(e):
827        print "b. m"
828      fn_name=e.opr      fn_name=e.opr
829      (fld1,fld2) =  apply.get_binary(e)      (fld1,fld2) =  apply.get_binary(e)
830      exp1 = field.get_data(fld1)      exp1 = field.get_data(fld1)
# Line 752  Line 835 
835          return  applyToMs(exp1, exp2, fn_subtract)          return  applyToMs(exp1, exp2, fn_subtract)
836      elif(op_modulate==fn_name):#modulate      elif(op_modulate==fn_name):#modulate
837          return applyToMs(exp1,exp2,fn_modulate)          return applyToMs(exp1,exp2,fn_modulate)
     elif(op_doubledot==fn_name):#op_doubledot  
         return fn_doubledot (fld1,fld2)  
838      else:      else:
839          return applyToExp_B_uneven(e)          return applyToExp_B_rest(e)
840    
841    def applyToExp_B_T3(e):
842        print "b. m"
843        fn_name=e.opr
844        (fld1,fld2) =  apply.get_binary(e)
845        exp1 = field.get_data(fld1)
846        exp2 = field.get_data(fld2)
847        if(op_add==fn_name):#addition
848            return applyToT3s(exp1, exp2,  fn_add)
849        elif(op_subtract==fn_name):#subtract
850            return  applyToT3s(exp1, exp2, fn_subtract)
851        elif(op_modulate==fn_name):#modulate
852            return applyToT3s(exp1,exp2,fn_modulate)
853        else:
854            return applyToExp_B_rest(e)
855    
856    
857  # ***************************  unary/binary operators ***************************  # ***************************  unary/binary operators ***************************
# Line 767  Line 863 
863      dim = field.get_dim(fld)      dim = field.get_dim(fld)
864      if(op_norm==fn_name):#norm      if(op_norm==fn_name):#norm
865          return fn_norm(fld, dim)          return fn_norm(fld, dim)
866      if(op_normalize==fn_name):#normalize      elif(op_normalize==fn_name):#normalize
867          x= fn_normalize(fld, dim)          x= fn_normalize(fld, dim)
868          return x          return x
869      elif (field.is_Scalar(fld)): # input is a scalar field      elif (field.is_Scalar(fld)): # input is a scalar field
# Line 785  Line 881 
881      # type is checked elsewhere or does not matter      # type is checked elsewhere or does not matter
882      if(op_division==fn_name): #division      if(op_division==fn_name): #division
883          return fn_division(f, g)          return fn_division(f, g)
884        elif(op_doubledot==fn_name):#op_doubledot
885            return fn_doubledot (f, g)
886        elif(op_outer==fn_name):
887            return fn_outer(f, g)
888        elif(op_inner==fn_name):
889            return fn_inner(f, g)
890        elif(op_scale==fn_name): #scaling
891            return fn_scaling(f,g)
892      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
893          return applyToExp_B_S(e)          return applyToExp_B_S(e)
894      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, _  
895              return applyToExp_B_V(e)              return applyToExp_B_V(e)
896      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)):  
897              return applyToExp_B_M(e)              return applyToExp_B_M(e)
898        elif (field.is_Ten3(f) and field.is_Ten3(g)):
899            return applyToExp_B_T3(e)
900          else:          else:
901              return  applyToExp_B_V(e)           return applyToExp_B_rest(e)
     else:  
          return applyToExp_B_V(e)  
902    
903  def applyUnaryOnce(oexp_inner,app_inner,app_outer):  def applyUnaryOnce(oexp_inner,app_inner,app_outer):
904      #print "applyUnaryOnce"      #print "applyUnaryOnce"
# Line 882  Line 982 
982    
983  # ***************************  evaluate at positions ***************************  # ***************************  evaluate at positions ***************************
984  #evaluate scalar field exp  #evaluate scalar field exp
985    def eval_d0(pos0, exp):
986        return exp
987    
988    
989  def eval_d1(pos0, exp):  def eval_d1(pos0, exp):
990      #print "eval vec d1"      #print "eval vec d1"
991      #print "exp:",exp      #print "exp:",exp
# Line 1021  Line 1125 
1125    
1126  def probeField(otyp1,pos, ortn):  def probeField(otyp1,pos, ortn):
1127      dim = fty.get_dim(otyp1)      dim = fty.get_dim(otyp1)
1128      #print "output type"+otyp1.name      print "output type"+otyp1.name
1129      if (dim==1):      if (dim==nonefield_dim):
1130            #still need to flatten
1131            rtn = []
1132            if (fty.is_Matrix(otyp1)):
1133                for i in ortn:
1134                    for j in i :
1135                        rtn.append(j)
1136                return [rtn]
1137            elif (fty.is_Ten3(otyp1)):
1138                for i in ortn:
1139                    for j in i :
1140                        for k in  j:
1141                            rtn.append(k)
1142                return [rtn]
1143    
1144            else:
1145                return [ortn]
1146    
1147        elif (dim==1):
1148          def get_k():          def get_k():
1149              if (fty.is_ScalarField(otyp1)): # output is a scalar field              if (fty.is_ScalarField(otyp1)): # output is a scalar field
1150                  #print "s_d1"                  #print "s_d1"

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

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