Class: NumRu::VArray

Inherits:
Object
  • Object
show all
Defined in:
lib/numru/gphys/varray.rb,
lib/numru/gphys/interpolate.rb,
lib/numru/gphys/gphys_dim_op.rb,
ext/numru/gphys/dim_op.c

Overview

class Units

Constant Summary collapse

Math_funcs_nondim = 
["exp","log","log10","log2","sin","cos","tan",
"sinh","cosh","tanh","asinh","acosh",
"atanh","csc","sec","cot","csch","sech","coth",
"acsch","asech","acoth"]
Math_funcs_radian = 
["asin","acos","atan","atan2","acsc","asec","acot"]
Math_funcs = 
Math_funcs_nondim + Math_funcs_radian + ["sqrt"]
Binary_operators_Uop = 
["*","/","**", ".mul!",".div!"]
Binary_operators_Uconv = 
["+","-",".add!",".sbt!"]
Binary_operators_Unone = 
["%",".mod!",".imag="]
Binary_operators = 
Binary_operators_Uop + 
Binary_operators_Uconv +
Binary_operators_Unone
Binary_operatorsL_comp = 
[">",">=","<","<=",
".eq",".ne",".gt",".ge",".lt",".le"]
Binary_operatorsL_other = 
["&","|","^",".and",".or",".xor",".not"]
Binary_operatorsL = 
Binary_operatorsL_comp +
Binary_operatorsL_other
Unary_operators = 
["-@","~"]
NArray_type1_methods =

type1 methods: returns a VArray with the same shape type2 methods: returns the result directly

["sort", "sort_index", 
"floor","ceil","round","to_f","to_i","to_type","abs",
"real","im","imag","angle","arg","conj","conjugate","cumsum",
"indgen","random"]
NArray_type2_methods1 = 
["all?","any?","none?","where","where2",
"to_a", "to_string"]
NArray_type2_methods2 = 
["rank", "shape", "total","length"]
NArray_type2_methods3 = 
["typecode"]
NArray_type3_methods = 
["mean","sum","stddev","min","max","median"]
NArray_type2_methods =

remaining: “transpose”

Array.new.push(*NArray_type2_methods1).
push(*NArray_type2_methods2).
push(*NArray_type2_methods3)
@@default_missval =

NC_FILL_DOUBLE/FLOAT ~15*2^119

9.9692099683868690e+36

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(narray = nil, attr = nil, name = nil) ⇒ VArray

< basic parts to be redefined in subclasses > ###



315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
 
# File 'lib/numru/gphys/varray.rb', line 315

def initialize(narray=nil, attr=nil, name=nil)
	 # initialize with an actual array --- initialization by subset
	 # mapping is made with VArray.new.initialize_mapping(...)
	 @name = ( name || "noname" )
	 @mapping = nil
	 @varray = nil
	 @ary = __check_ary_class(narray)
	 case attr
	 when Attribute
	    @attr = attr
	 when VArray
	    vary = attr
	    @attr = vary.attr_copy
	 when Hash
	    @attr = NumRu::Attribute.new
	    attr.each{|key,val| @attr[key]=val}
	 when nil
	    @attr = NumRu::Attribute.new
	 else
	   raise TypeError, "#{attr.class} is unsupported for the 2nd arg"
	 end
end

Class Method Details

.new2(ntype, shape, attr = nil, name = nil) ⇒ Object 



349
350
351
352
 
# File 'lib/numru/gphys/varray.rb', line 349

def VArray.new2(ntype, shape, attr=nil, name=nil)
	 ary = NArray.new(ntype, *shape)
	 VArray.new(ary, attr, name)
end

Instance Method Details

#+@ ⇒ Object 



917
918
919
 
# File 'lib/numru/gphys/varray.rb', line 917

def +@
	self
end

#[](*slicer) ⇒ Object 



573
574
575
576
577
 
# File 'lib/numru/gphys/varray.rb', line 573

def [](*slicer)
	 slicer = __rubber_expansion( slicer )
	 mapping = SubsetMapping.new(self.shape_current, slicer)
	 VArray.new.initialize_mapping(mapping, self)
end

#[]=(*args) ⇒ Object 



579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
 
# File 'lib/numru/gphys/varray.rb', line 579

def []=(*args)
	 val = args.pop
	 slicer = args
	 slicer = __rubber_expansion( slicer )
	 if val.is_a?(VArray)
	    val = val.val
	 else
	    val = __check_ary_class2(val)
	 end
	 if @mapping
	    sl= @mapping.composite(SubsetMapping.new(self.shape,slicer)).slicer
	    @varray[*sl]=val
	 else
	    @ary[*slicer]=val
	 end
	 val
end

#att_names ⇒ Object 



516
517
518
 
# File 'lib/numru/gphys/varray.rb', line 516

def att_names
	attr.keys
end

#attr_copy(to = nil) ⇒ Object 



512
513
514
 
# File 'lib/numru/gphys/varray.rb', line 512

def attr_copy(to=nil)
	attr.copy(to)
end

#axis_cyclic? ⇒ Boolean

Returns:

  • (Boolean) 


628
629
630
 
# File 'lib/numru/gphys/varray.rb', line 628

def axis_cyclic?
  axis_modulo != nil
end

#axis_cyclic_extendible? ⇒ Boolean

Returns:

  • (Boolean) 


658
659
660
661
662
663
664
665
666
667
668
 
# File 'lib/numru/gphys/varray.rb', line 658

def axis_cyclic_extendible?
  modulo = axis_modulo
  return false if !modulo
  v = val
  width = (v[-1] - v[0]).abs
	dx = width / (length-1)
	eps = 1e-4
	modulo = modulo.abs
	extendible = ( ((width+dx) - modulo).abs < eps*modulo )
  return extendible
end

#axis_draw_positive ⇒ Object 



613
614
615
616
617
618
619
620
621
622
623
624
625
626
 
# File 'lib/numru/gphys/varray.rb', line 613

def axis_draw_positive
	# Default setting is taken from a widely used netcdf convention.
	# You can override it in a sub-class or using convention specific 
	# mixins.
	positive = attr['positive']
	case positive
	when /up/i
	  true
	when /down/i
	  false
	else
	  nil    # not defined, or if not 'up' or 'down'
	end  
end

#axis_modulo ⇒ Object 



632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
 
# File 'lib/numru/gphys/varray.rb', line 632

def axis_modulo
	# Default setting is taken from a widely used netcdf convention.
	# You can override it in a sub-class or using convention specific 
	# mixins.
	if attval=attr['modulo']
	  if attval.is_a?(String)
	    attval.to_f
	  else
	    attval[0]
	  end
	elsif /degrees?_east/ =~ attr['units']
    360.0     # special treatment: a common convention for the earth
  elsif (tp = attr['topology']) and (/circular/i =~ tp)
    un = Units[attr['units']]
    if un == Units['degrees']
	    360.0
    elsif un == Units['radian']
      2*Math::PI
    else
      nil    # cannot guess --> nil
    end
  else
    nil      # not defined --> nil
	end
end

#bin_mean(dim, len, nminvalid = 1) ⇒ Object 



152
153
154
155
156
157
158
159
160
161
162
 
# File 'lib/numru/gphys/gphys_dim_op.rb', line 152

def bin_mean(dim, len, nminvalid=1)
  vi = self.val
  if vi.is_a?(NArrayMiss)
    vi, missval = nam2na_missval(vi)
    vo = c_bin_mean(vi,dim,len,missval,nminvalid)  # defined in dim_op.c
    vo = NArrayMiss.to_nam(vo, vo.ne(missval) )
  else
    vo = c_bin_mean(vi,dim,len)  # defined in dim_op.c
  end
  VArray.new( vo, self, self.name )  # Inherit name & attrs 
end

#bin_sum(dim, len, nminvalid = 1) ⇒ Object 



164
165
166
167
168
169
170
171
172
173
174
 
# File 'lib/numru/gphys/gphys_dim_op.rb', line 164

def bin_sum(dim, len, nminvalid=1)
  vi = self.val
  if vi.is_a?(NArrayMiss)
    vi, missval = nam2na_missval(vi)
    vo = c_bin_sum(vi,dim,len,missval,nminvalid)  # defined in dim_op.c
    vo = NArrayMiss.to_nam(vo, vo.ne(missval) )
  else
    vo = c_bin_sum(vi,dim,len)  # defined in dim_op.c
  end
  VArray.new( vo, self, self.name )  # Inherit name & attrs 
end

#coerce(other) ⇒ Object

ToDo: implement units handling ToDo: coerce



675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
 
# File 'lib/numru/gphys/varray.rb', line 675

def coerce(other)
	case other
	when UNumeric
    oattr = self.attr_copy
	  oattr['units'] = other.units.to_s
	  na_other, = NArray.new(self.typecode, 1).coerce(other.val)   # scalar
	  c_other = VArray.new(na_other, oattr, self.name)
	else
	  case other
	  when Numeric, Array, NArrayMiss
	    c_other = UNumeric::Num2Coerce.new( other )
	  else
	    raise "Cannot coerse #{other.class}"
	  end
	end
	[c_other, self]
end

#convert_units(to) ⇒ Object 



544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
 
# File 'lib/numru/gphys/varray.rb', line 544

def convert_units(to)
	if ! to.is_a?(Units)
	  to = Units.new(to)
	end
	myunits = self.units
	if myunits != to
	  if calendar = self.get_att("calendar")
	    date0 = UNumeric.new(0,myunits).to_datetime
	    un0 = UNumeric.from_date(date0,to,calendar)
	    offset = un0.to_f
	    gp = self + offset
	  else
	    gp = myunits.convert2(self, to)
	  end
	  gp.units = to
	  gp
	else
	  self   # returns self (no duplication)
	end
end

#copy(to = nil) ⇒ Object

< basic parts invariant in subclasses > ###



457
458
459
460
461
462
463
464
465
466
467
468
469
 
# File 'lib/numru/gphys/varray.rb', line 457

def copy(to=nil)
	 attr = self.attr_copy( (to ? to.attr : to) )
	 val = self.val
	 if self.class==VArray && !self.mapped? && (to==nil || to.class==VArray)
	    val = val.dup
	 end
	 if to
	    to.val = val
	    to
	 else
	    VArray.new(val, attr, self.name)
	 end
end

#del_att(name) ⇒ Object 



526
527
528
 
# File 'lib/numru/gphys/varray.rb', line 526

def del_att(name)
	attr.delete(name)
end

#file ⇒ Object 



447
448
449
450
451
452
453
 
# File 'lib/numru/gphys/varray.rb', line 447

def file
	if @mapping
	  @varray.file
	else
	  return nil
	end
end

#get_att(name) ⇒ Object 



519
520
521
 
# File 'lib/numru/gphys/varray.rb', line 519

def get_att(name)
	attr[name]
end

#inspect ⇒ Object 



341
342
343
344
345
346
347
 
# File 'lib/numru/gphys/varray.rb', line 341

def inspect
	 if !@mapping
      "<'#{name}' #{ntype}#{shape.inspect} val=[#{(0...(4<length ? 4 : length)).collect do |i| @ary[i].to_s+',' end}#{'...' if 4<length}]>"
	 else
	    "<'#{name}' shape=#{shape.inspect}  subset of a #{@varray.class}>"
	 end
end

#long_name ⇒ Object 



565
566
567
 
# File 'lib/numru/gphys/varray.rb', line 565

def long_name
	attr['long_name']
end

#long_name=(nm) ⇒ Object 



569
570
571
 
# File 'lib/numru/gphys/varray.rb', line 569

def long_name=(nm)
	attr['long_name'] = nm
end

#mapped? ⇒ Boolean

def reshape( *shape )

# reshape method that returns a new entire copy (deep one).
# ToDo :: prepare another reshape method that does not make the
# entire copy (you could use NArray.refer, but be careful not 
# to make it public, because it's easily misused)
newobj = self.copy
newobj.ary.reshape!( *shape )
newobj

end

Returns:

  • (Boolean) 


481
482
483
 
# File 'lib/numru/gphys/varray.rb', line 481

def mapped?
	 @mapping ? true : false
end

#marshal_dump ⇒ Object

< marshal dump/load >



976
977
978
 
# File 'lib/numru/gphys/varray.rb', line 976

def marshal_dump
  [@name, @mapping, @varray, @ary, @attr]
end

#marshal_load(ary) ⇒ Object 



980
981
982
 
# File 'lib/numru/gphys/varray.rb', line 980

def marshal_load(ary)
  @name, @mapping, @varray, @ary, @attr = *ary
end

#name ⇒ Object 



597
598
599
600
601
602
603
 
# File 'lib/numru/gphys/varray.rb', line 597

def name
	 if @mapping
	    @varray.name
	 else
	    @name.dup
	 end
end

#name=(nm) ⇒ Object

Raises:

  • (ArgumentError) 


421
422
423
424
425
426
427
428
429
 
# File 'lib/numru/gphys/varray.rb', line 421

def name=(nm)
	 raise ArgumentError, "name should be a String" if ! nm.is_a?(String)
	 if @mapping
	    @varray.name = nm
	 else
	    @name = nm
	 end
	 nm
end

#ntype ⇒ Object 



417
418
419
 
# File 'lib/numru/gphys/varray.rb', line 417

def ntype
  __ntype(typecode)
end

#rename(nm) ⇒ Object 



434
435
436
 
# File 'lib/numru/gphys/varray.rb', line 434

def rename(nm)
	self.dup.rename!(nm)
end

#rename!(nm) ⇒ Object 



430
431
432
433
 
# File 'lib/numru/gphys/varray.rb', line 430

def rename!(nm)
	 self.name=nm
	 self
end

#replace_val(narray) ⇒ Object 



398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
 
# File 'lib/numru/gphys/varray.rb', line 398

def replace_val(narray)
	narray = __check_ary_class(narray)
	if self.class != VArray
	  raise "replace_val to #{self.class} is disabled. Use val= instead"
	end
	if narray.shape != shape 
	  raise "shape of the argument (#{narray.shape.inspect}) !="+
	    " self.shape (#{shape.inspect})"
	end
	@ary = narray
	if @mapping
	  # to non subset
	  @name = @varray.name
	  @attr = @varray.attr_copy
	  @mapping = @varray = nil
	end
	self
end

#reshape(*shape) ⇒ Object 



609
610
611
 
# File 'lib/numru/gphys/varray.rb', line 609

def reshape(*shape)
	VArray.new( val.reshape(*shape), attr_copy, name )
end

#reshape!(*shape) ⇒ Object 



438
439
440
441
442
443
444
445
 
# File 'lib/numru/gphys/varray.rb', line 438

def reshape!( *shape )
	if @mapping
	  raise "Cannot reshape an VArray mapped to another. Use copy first to make it independent"
	else
	  @ary.reshape!( *shape )
	end
	self
end

#set_att(name, val) ⇒ Object Also known as: put_att 



522
523
524
525
 
# File 'lib/numru/gphys/varray.rb', line 522

def set_att(name, val)
	attr[name]=val
	self
end

#sqrt ⇒ Object 



768
769
770
771
772
 
# File 'lib/numru/gphys/varray.rb', line 768

def sqrt
	va = VArray.new( Misc::EMath.sqrt(self.val), self.attr_copy, self.name )
	va.units = units**Rational(1,2)
	va
end

#to_g1D ⇒ Object 



784
785
786
787
788
 
# File 'lib/numru/gphys/interpolate.rb', line 784

def to_g1D
  ax = Axis.new().set_pos(self)
  grid = Grid.new(ax)
  GPhys.new(grid,self)
end

#transpose(*dims) ⇒ Object 



605
606
607
 
# File 'lib/numru/gphys/varray.rb', line 605

def transpose(*dims)
	VArray.new( val.transpose(*dims), attr_copy, name )
end

#units ⇒ Object 



531
532
533
534
535
536
537
 
# File 'lib/numru/gphys/varray.rb', line 531

def units
	str_units = attr['units']
	if !str_units || str_units==''
	  str_units = '1'              # represents non-dimension
	end
	Units.new( str_units )
end

#units=(units) ⇒ Object 



539
540
541
542
 
# File 'lib/numru/gphys/varray.rb', line 539

def units=(units)
	attr['units'] = units.to_s
	units
end

#val ⇒ Object 



354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
 
# File 'lib/numru/gphys/varray.rb', line 354

def val
	if @mapping
	  ary = @varray.ary
	  slicer = @mapping.slicer
	  if ary.is_a?(NArray) || ary.is_a?(NArrayMiss)
	    # interpret Hash slicers for NArray/NArrayMiss 
	    #   -- this part would not be needed if NArray supported it.
	    new_slicer = Array.new
	    for idx in 0...slicer.length
 sl = slicer[idx]
 if sl.is_a?(Hash)
		range, step = sl.to_a[0]
		dim_len = ary.shape[idx]
		first = range.first
		first += dim_len if first<0
		last = range.last
		last += dim_len if last<0
		if first<0 || first>=dim_len || last<0 || last>=dim_len || step==0
		  raise "slicer #{slicer.inspect} for dim #{idx} is invalid (dim_len=#{dim_len})"
		end
		step = -step if ( (last-first)*step < 0 )
		length = (last-first) / step + 1
		new_slicer[idx] = first + step * NArray.int(length).indgen!
 else
		new_slicer[idx] = sl
 end
	    end
	    slicer = new_slicer
	  end
	  ary[*slicer]
	else
	  @ary.dup
	end
end

#val=(narray) ⇒ Object 



389
390
391
392
393
394
395
396
 
# File 'lib/numru/gphys/varray.rb', line 389

def val=(narray)
	 if @mapping
	    @varray.ary[*@mapping.slicer] = __check_ary_class2(narray)
	 else
	    @ary[] = __check_ary_class2(narray)
	 end
	 narray
end