Coverage for m_pool\matrix_obj.py : 30%

Hot-keys on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
except: print("...WARNING... scipy.optimize.minimize did NOT import...") print(" ... min/max functions are UNAVAILABLE ...")
'''An Matrix object holds data for N dimensional data There are N Axis objects for the data.
The data is a single number indexed by the axes index values.
*** Structured to easily pickle via a dictionary of named values for properties. *** '''
'axisNameL':None, 'axisPoolObj':None} ): '''Initialize with a dictionary so that pickle files can easily save and read objects
axisNameL holds the names of axes that are in the axisPoolObj. The Matrix is dimensioned by the size of the axes in the order specified.
An Axis obj can be shared by many Matrix objects. '''
# Let it crash if axisNameL and axisPoolObj are not specified except: print('ERROR... both axisNameL and axisPoolObj MUST be specified in Matrix') sys.exit()
# Init to Zeros if axes specified, but data not specified
# temporary list of numpy matrices used for interpolation
return self.solve_interp_minmax( find_min=True, order=order, method=method, tol=tol)
return self.solve_interp_minmax( find_min=False, order=order, method=method, tol=tol)
order=3, method='TNC', tol=1.0E-8): # method can be: SLSQP, TNC
boundsL = [] startValL = [] axisNameL = [] mn,mx = self.get_min_max() range = mx - mn interpD = {} # dictionary of axis values
if find_min: iminmax = self.get_minima_indeces() else: iminmax = self.get_peak_indeces()
for i,im in enumerate( iminmax ): #print 'minmax value at %s=%g'%(self.axisL[i].name, self.axisL[i][im]) #EPS=1.0E-10*abs(self.axisL[i][-1] - self.axisL[i][0]) boundsL.append( (self.axisL[i][0],self.axisL[i][-1]) ) startValL.append( self.axisL[i][im] ) axisNameL.append( self.axisL[i].name ) interpD[self.axisL[i].name] = self.axisL[i][im] #print 'minmax value =',self.matValArr[ iminmax ],' Min =',mn,' Max =',mx #print 'boundsL =',boundsL #print 'startValL =',startValL #print 'axisNameL =',axisNameL #print 'interpD =',interpD
def fun( row ): # row is in axis-order from self.axisL for i,val in enumerate(row): interpD[ axisNameL[i] ] = val mval = self.interp(order=order, **interpD )
norm_val = float( (mval-mn)/range ) # normalize to help convergence if find_min: return norm_val else: return -norm_val
res = minimize(fun, tuple(startValL), method=method, bounds=tuple(boundsL), tol=tol, options={'disp':False}) print(res)
fun( res.x )# make sure interpD is set
minmax_val = float( self.interp( **interpD ) )
return interpD, minmax_val
''' Call as: M.interp(order=3, pc=100, eps=20, mr=2.0)
Uses scipy.interpolate.interp1d '''
# Only generate list of temporary matrices if 1st time, or if shape change #print 'orig shape =',self.matValArr.shape
#remove first dimension from each subsequent member of self.terp_mL #print 'next_shape =',next_shape #print 'next_shape =',next_shape else:
# interp from previous matrix for next matrix #print '... interpolating into',A.name,' xval=',xval,A # mindeces is a tuple index into m # indeces is index into last m
#print 'mindeces =',mindeces #print indeces, val #print 'xL=',A.transArr #print 'yL=',yL except: print('Extrapolating',A.name,'axis =',A.transArr,' xval=',xval) print(' yL =',yL) if xval>=A.transArr[-2]: m[mindeces] = yL[-1] # assume out of bounds at high end else: m[mindeces] = yL[0] # assume out of bounds at low end
#print 'Last matrix(array) =',self.terp_mL[-1] #print 'm =',m #print 'axis =',A,' xval=',xval except: print('Extrapolating','axis =',A,' xval=',xval) print(' m =',m) if xval>=A.transArr[-2]: result = m[-1] # assume out of bounds at high end else: result = m[0] # assume out of bounds at low end
#print 'type(result)=',type(result), result.shape #return result
return np.count_nonzero( self.matValArr )
ntotal = 1 for i in self.matValArr.shape: ntotal *= i nfull = np.count_nonzero( self.matValArr ) return (100*nfull) / ntotal
'''Note that matrix_pool supplies axisPoolObj for pickled Matrix''' return {'name':self.name, 'matValArr':self.matValArr, 'units':self.units, 'axisNameL':self.axisNameL}
newMat = np.insert( self.matValArr, i, 0.0, axis=iaxis ) self.matValArr = newMat
if self.matValArr is None: sL = ['Matrix %s (shape=%s) %s (units=%s)'%(self.name, str(self.matValArr),self.name, self.units)] else: sL = ['Matrix %s (shape=%s) %s (units=%s)'%(self.name, str(self.matValArr.shape),self.name, self.units)] for A in self.axisL: s = str(A) ssL = s.split('\n') for s in ssL: sL.append( ' ' + s ) #sL.append( str(A) )
return '\n'.join( sL )
s = self.short_summ() sL = s.split('\n') #if self.matValArr is None: # sL = ['Matrix %s (shape=%s) %s (units=%s)'%(self.name, str(self.matValArr),self.name, self.units)] #else: # sL = ['Matrix %s (shape=%s) %s (units=%s)'%(self.name, str(self.matValArr.shape),self.name, self.units)] #for A in self.axisL: # sL.append( str(A) )
sL.append( str(self.matValArr) ) return '\n'.join( sL )
return self.matValArr[ tuple(iL) ]
if val is None: print('ERROR... illegal value for "val" in Matrix.set. val =',val) else: self.matValArr[iL] = float(val)
'''Call as: M.setByName(pc=100, eps=20, mr=2.0, val=29.23)'''
'''Call as: M.getByName(pc=100, eps=20, mr=2.0)'''
iL = [] # list of indeces into matrix array for A in self.axisL: iL.append( A.getExactIndex( kwds[A.name] ) ) return self.matValArr[tuple(iL)]
imax = np.unravel_index(self.matValArr.argmax(), self.matValArr.shape) return imax
imin = np.unravel_index(self.matValArr.argmin(), self.matValArr.shape) return imin
return np.nanmin(self.matValArr), np.nanmax(self.matValArr)
return np.nanmin(self.matValArr)
return np.nanmax(self.matValArr)
return np.nansum(self.matValArr)
return np.average(self.matValArr)
return np.mean(self.matValArr)
return np.std(self.matValArr)
return np.median(self.matValArr)
return np.ptp(self.matValArr) # peak to peak
return len( self.matValArr )
return self.matValArr.shape
return np.prod( self.matValArr.shape )
for indeces in itertools.product(*(list(range(s)) for s in self.matValArr.shape)): yield indeces
for indeces in itertools.product(*(list(range(s)) for s in self.matValArr.shape)): val = self.matValArr[indeces] yield indeces,val
self.axisNameL for indeces in itertools.product(*(list(range(s)) for s in self.matValArr.shape)): val = self.matValArr[indeces] D={} for i,axname in enumerate( self.axisNameL ): D[axname] = self.axisL[ i ][indeces[i]] yield indeces,D,val
Mclone = copy.deepcopy( self ) Mclone.name = self.name + '(clone)' return Mclone
Mclone = self.clone() Mclone.matValArr = np.negative( Mclone.matValArr ) return Mclone
return self * (-1.0)
Mclone = self.clone() Mclone.matValArr = abs(self.matValArr) return Mclone
Mclone = self.clone() if isinstance(other, Matrix): Mclone.name = self.name + ' + %s'%other.name Mclone.matValArr = self.matValArr + other.matValArr else: Mclone.name = self.name + ' + %s'%other Mclone.matValArr = self.matValArr + other return Mclone
return self.__add__(other)
if isinstance(other, Matrix): self.name = self.name + ' + %s'%other.name self.matValArr = self.matValArr + other.matValArr else: self.name = self.name + ' + %s'%other self.matValArr = self.matValArr + other return self
Mclone = self.clone() if isinstance(other, Matrix): Mclone.name = self.name + ' - %s'%other.name Mclone.matValArr = self.matValArr - other.matValArr else: Mclone.name = self.name + ' - %s'%other Mclone.matValArr = self.matValArr - other return Mclone
Mclone = self.clone() Mclone.matValArr = np.negative( Mclone.matValArr ) return Mclone + other
if isinstance(other, Matrix): self.name = self.name + ' - %s'%other.name self.matValArr = self.matValArr - other.matValArr else: self.name = self.name + ' - %s'%other self.matValArr = self.matValArr - other return self
Mclone = self.clone() if isinstance(other, Matrix): Mclone.name = self.name + ' * %s'%other.name Mclone.matValArr = self.matValArr * other.matValArr else: Mclone.name = self.name + ' * %s'%other Mclone.matValArr = self.matValArr * other return Mclone
return self * other
if isinstance(other, Matrix): self.name = self.name + ' * %s'%other.name self.matValArr = self.matValArr * other.matValArr else: self.name = self.name + ' * %s'%other self.matValArr = self.matValArr * other return self
Mclone = self.clone() if isinstance(other, Matrix): Mclone.name = self.name + ' / %s'%other.name Mclone.matValArr = self.matValArr / other.matValArr else: Mclone.name = self.name + ' / %s'%other Mclone.matValArr = self.matValArr / other return Mclone
Mclone = self.clone() Mclone.matValArr = np.reciprocal( Mclone.matValArr ) return Mclone * other
#print ' plain div' if isinstance(other, Matrix): self.name = self.name + ' / %s'%other.name self.matValArr = self.matValArr / other.matValArr else: self.name = self.name + ' / %s'%other self.matValArr = self.matValArr / other return self
return self.__div__(other)
return self.__rdiv__(other)
#print 'truediv' return self.__idiv__(other)
Mclone = self.clone() if isinstance(other, Matrix): Mclone.name = self.name + ' ** %s'%other.name Mclone.matValArr = self.matValArr ** other.matValArr else: Mclone.name = self.name + ' ** %s'%other Mclone.matValArr = self.matValArr ** other return Mclone
Mclone = self.clone() Mclone.matValArr = (Mclone.matValArr*0.0) + other return Mclone**self
#print ' plain div' if isinstance(other, Matrix): self.name = self.name + ' ** %s'%other.name self.matValArr = self.matValArr ** other.matValArr else: self.name = self.name + ' ** %s'%other self.matValArr = self.matValArr ** other return self
'''Call as: M.get_sub_matrix(pc=100, eps=20, mr=2.0) Return a smaller Matrix at specified values in kwds'''
is_in_cutL=[0 for axname in self.axisNameL] # set to 1 if axname is a cut plane orig_indexL = is_in_cutL[:] # hold index into axis for input axis value newAxisNameL = [] # smaller list of axis names in new, smaller Matrix for ia,axname in enumerate(self.axisNameL): if axname in kwds: is_in_cutL[ia]=1
# Also hold const index in cut axis orig_indexL[ia] = self.axisL[ia].getExactIndex( kwds[axname] ) else: newAxisNameL.append( axname )
#print 'is a slice plane =',is_in_cutL #print 'Index of slice plane =',orig_indexL
new_name = self.name +'_'+ '_'.join( ['%s=%s'%(n,v) for n,v in list(kwds.items())] ) M = Matrix( {'name':new_name, 'units':self.units, 'axisNameL':newAxisNameL, 'axisPoolObj':self.axisPoolObj} )
# TODO: change to faster numpy slicing method. for new_indeces in M.iter_indeces(): inew = 0 for i,ia in enumerate(is_in_cutL): if ia==0: # if axis in new Matrix, iterate indeces orig_indexL[i] = new_indeces[inew] inew += 1 M[ tuple(new_indeces) ] = self.matValArr[ tuple(orig_indexL) ]
return M
epsAxis = Axis({'name':'eps', 'valueL':[10., 20., 30., 40.], 'units':'', 'transform':'log10'})
# Just a dict, not an Axis obj pcAxis = {'name':'pc', 'valueL':[100.,200.,300], 'units':'psia', 'transform':'log10'}
mrAxis = Axis({'name':'mr', 'valueL':[1,2,3,4,5], 'units':'', 'transform':''})
axesDefL = [epsAxis, pcAxis, mrAxis]
AP = AxisPool( {'axesDefL':axesDefL} )
axisNameL = ['eps','pc','mr'] shape = [len(AP.axisD[name]) for name in axisNameL] print('shape =',shape) matValArr = np.zeros( shape ) n0,n1,n2 = axisNameL for i0,v0 in enumerate(AP.axisD[n0]): for i1,v1 in enumerate(AP.axisD[n1]): for i2,v2 in enumerate(AP.axisD[n2]): matValArr[i0,i1,i2] = v0+v1+v2
M = Matrix( {'name':'isp_ode', 'matValArr':matValArr, 'units':'', 'axisNameL':axisNameL, 'axisPoolObj':AP} )
#print M.axisL print(M) #print type( M.axisL[0] ) == Axis #print type( {1:1} ) == dict print(M[(0,0,0)],M[3,2,4],'__getitem__ examples') print('_'*55) print(mrAxis.matrixConnectionL) #epsAxis.add_value( 16.0 ) j = AP.add_value_to_Axis('pc', 250.0) print(M) print(' ...Added new axis value. Matrix expands to accomodate') print('_'*55) for i in range( len(epsAxis) ): for k in range( len(mrAxis) ): M[(i,j,k)] = 7777.0 print(M) print(' ...Set inserted value to 7777. Use index from axis value insert.') print('_'*55)
print() pc = 250.0 for eps in epsAxis: for mr in mrAxis: M.setByName( pc=pc, eps=eps, mr=mr, val=9999.0 ) print(M) print(' ...change 7777 to 9999 using dictionary indexing pc=pc.') print('_'*55)
|