Coverage for /wheeldirectory/casa-6.7.0-12-py3.10.el8/lib/py/lib/python3.10/site-packages/casatools/__casac__/quanta.py: 57%

1# This file was automatically generated by SWIG (http://www.swig.org). 

2# Version 3.0.12 

3# 

4# Do not make changes to this file unless you know what you are doing--modify 

5# the SWIG interface file instead. 

6 

7from sys import version_info as _swig_python_version_info 

8if _swig_python_version_info >= (2, 7, 0): 

9 def swig_import_helper(): 

10 import importlib 

11 pkg = __name__.rpartition('.')[0] 

12 mname = '.'.join((pkg, '_quanta')).lstrip('.') 

13 try: 

14 return importlib.import_module(mname) 

15 except ImportError: 

16 return importlib.import_module('_quanta') 

17 _quanta = swig_import_helper() 

18 del swig_import_helper 

19elif _swig_python_version_info >= (2, 6, 0): 

20 def swig_import_helper(): 

21 from os.path import dirname 

22 import imp 

23 fp = None 

24 try: 

25 fp, pathname, description = imp.find_module('_quanta', [dirname(__file__)]) 

26 except ImportError: 

27 import _quanta 

28 return _quanta 

29 try: 

30 _mod = imp.load_module('_quanta', fp, pathname, description) 

31 finally: 

32 if fp is not None: 

33 fp.close() 

34 return _mod 

35 _quanta = swig_import_helper() 

36 del swig_import_helper 

37else: 

38 import _quanta 

39del _swig_python_version_info 

40 

41try: 

42 _swig_property = property 

43except NameError: 

44 pass # Python < 2.2 doesn't have 'property'. 

45 

46try: 

47 import builtins as __builtin__ 

48except ImportError: 

49 import __builtin__ 

50 

51def _swig_setattr_nondynamic(self, class_type, name, value, static=1): 

52 if (name == "thisown"): 

53 return self.this.own(value) 

54 if (name == "this"): 

55 if type(value).__name__ == 'SwigPyObject': 

56 self.__dict__[name] = value 

57 return 

58 method = class_type.__swig_setmethods__.get(name, None) 

59 if method: 

60 return method(self, value) 

61 if (not static): 

62 if _newclass: 

63 object.__setattr__(self, name, value) 

64 else: 

65 self.__dict__[name] = value 

66 else: 

67 raise AttributeError("You cannot add attributes to %s" % self) 

68 

69 

70def _swig_setattr(self, class_type, name, value): 

71 return _swig_setattr_nondynamic(self, class_type, name, value, 0) 

72 

73 

74def _swig_getattr(self, class_type, name): 

75 if (name == "thisown"): 

76 return self.this.own() 

77 method = class_type.__swig_getmethods__.get(name, None) 

78 if method: 

79 return method(self) 

80 raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name)) 

81 

82 

83def _swig_repr(self): 

84 try: 

85 strthis = "proxy of " + self.this.__repr__() 

86 except __builtin__.Exception: 

87 strthis = "" 

88 return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) 

89 

90try: 

91 _object = object 

92 _newclass = 1 

93except __builtin__.Exception: 

94 class _object: 

95 pass 

96 _newclass = 0 

97 

98class quanta(_object): 

99 """Proxy of C++ casac::quanta class.""" 

100 

101 __swig_setmethods__ = {} 

102 __setattr__ = lambda self, name, value: _swig_setattr(self, quanta, name, value) 

103 __swig_getmethods__ = {} 

104 __getattr__ = lambda self, name: _swig_getattr(self, quanta, name) 

105 __repr__ = _swig_repr 

106 

107 def __init__(self): 

108 """__init__(self) -> quanta""" 

109 this = _quanta.new_quanta() 

110 try: 

111 self.this.append(this) 

112 except __builtin__.Exception: 

113 self.this = this 

114 

115 def convertfreq(self, *args, **kwargs): 

116 """ 

117 convertfreq(self, _v, _outunit) -> record * 

118 

119 

120 

121 Summary: 

122 convert a frequency quantity to another unit 

123 

124 Description: 

125 

126 

127 convertfreq converts a frequency quantity to another unit. 

128 

129 Input Parameters: 

130 v quantity to convert 

131 outunit unit to convert to 

132 

133 Example: 

134 

135 

136 # 

137 print 't----t convertfreq Ex 1 t----' 

138 print qa.convertfreq('5GHz','cm') 

139 #{'value': 5.9958491599999997, 'unit': 'cm'} 

140 print qa.convertfreq('5cm','GHz') 

141 #{'value': 5.9958491599999997, 'unit': 'GHz'} 

142 # 

143 

144 

145 -------------------------------------------------------------------------------- 

146 

147 """ 

148 return _quanta.quanta_convertfreq(self, *args, **kwargs) 

149 

150 

151 def convertdop(self, *args, **kwargs): 

152 """ 

153 convertdop(self, _v, _outunit) -> record * 

154 

155 

156 

157 Summary: 

158 convert a doppler velocity quantity to another unit 

159 

160 Description: 

161 

162 

163 convertfreq converts a velocity quantity to another unit. Units are either 

164 velocity or dimensionless. 

165 

166 Input Parameters: 

167 v quantity to convert 

168 outunit unit to convert to 

169 

170 Example: 

171 

172 

173 # 

174 print 't----t convertdop Ex 1 t----' 

175 print qa.convertdop('1','km/s') 

176 #{'value': 299792.45799999998, 'unit': 'km/s'} 

177 print qa.convertdop('10km/s','1') 

178 #{'value': 3.3356409519815205e-05, 'unit': '1'} 

179 # 

180 

181 

182 -------------------------------------------------------------------------------- 

183 

184 """ 

185 return _quanta.quanta_convertdop(self, *args, **kwargs) 

186 

187 

188 def quantity(self, *args, **kwargs): 

189 """ 

190 quantity(self, _v, _unitname, _keepshape) -> record * 

191 

192 

193 

194 Summary: 

195 make a quantity from a string or from a numeric value and a unit string 

196 

197 Description: 

198 

199 

200 quantity makes a quantity from a string, or from a value and a 

201 string. Note that a function unit exists which is a synonym for 

202 quantity. If only a string is given, it can be a scalar string. 

203 The result will be a scalar quantity. 

204 

205 

206 If a numeric value and a unit string 

207 are given, the numeric value can be any numeric type, and can also be 

208 a vector of numeric values. print qa.map() to get a list of recognized units. 

209 'd' is usually days, but can be degrees (see example). 

210 

211 The keepshape input parameter is only relevant if v is a multi-dimensional array. 

212 In this case, if true, the output value array will have the same shape as v. If false, 

213 a one-dimensional array is returned with length equal to the number of elements in 

214 v. The default value is false in order to preserve backward compatibility with 

215 previous versions. 

216 

217 Input Parameters: 

218 v quantity or numeric or string to convert to quantity 

219 unitname unit string if v numeric 

220 keepshape Only used if input parameter v is a multi-dimensional array. Output array will have the same shape as v. 

221 

222 Example: 

223 

224 

225 # 

226 print 't----t quantity Ex 1 t----' 

227 tu = qa.quantity('1Jy')# make quantity 

228 print tu 

229 #{'value': 1.0, 'unit': 'Jy'} 

230 print qa.quantity(tu)# also accepts a quantity 

231 #{'value': 1.0, 'unit': 'Jy'} 

232 tu = qa.unit('1Jy')# make quantity with synonym 

233 print tu 

234 #{'value': 1.0, 'unit': 'Jy'} 

235 print qa.quantity(-1.3, 'Jy')# make quantity with separate value 

236 #{'value': -1.3, 'unit': 'Jy'} 

237 q1 = qa.quantity([8.57132661e+09, 1.71426532e+10], 'km/s') # Composite unit 

238 print q1 

239 #{'value': array([ 8.57132661e+09, 1.71426532e+10]), 'unit': 'km/s'} 

240 q = qa.quantity('5d'); print q 

241 #{'value': 5.0, 'unit': 'd'} # d = days 

242 q = qa.quantity('5 d'); print q 

243 #{'value': 5.0, 'unit': 'd'} # even if there's a space, as of 5/28/09 

244 q = qa.quantity('5d30m'); print q 

245 #{'value': 5.5, 'unit': 'deg'} # Unless followed by an m! 

246 qa.quantity('5d30s') # WRONG 

247 # {'unit': 'd30s', 'value': 5.0} # I told you... 

248 qa.quantity('5d0m30s') # OK 

249 # {'unit': 'deg', 'value': 5.0083333333333337} 

250 

251 

252 -------------------------------------------------------------------------------- 

253 

254 """ 

255 return _quanta.quanta_quantity(self, *args, **kwargs) 

256 

257 

258 def getvalue(self, *args, **kwargs): 

259 """ 

260 getvalue(self, _v) -> std::vector< double > 

261 

262 

263 

264 Summary: 

265 get the internal value of a quantity 

266 

267 Description: 

268 

269 

270 getvalue returns the internal value of a quantity. It also can handle a 1-D 

271 array of quantities, but multi-dimensional arrays are not supported. 

272 

273 Input Parameters: 

274 v quantity 

275 

276 Example: 

277 

278 

279 # 

280 print 't----t getvalue Ex 1 t----' 

281 tu = qa.quantity(-1.3, 'Jy') # make quantity 

282 print tu 

283 #{'value': -1.3, 'unit': 'Jy'} 

284 print qa.getvalue(tu) 

285 #-1.3 

286 print qa.getunit(tu) 

287 #Jy 

288 a = qa.quantity([3,5],'cm') 

289 print a 

290 #{'value': array([ 3., 5.]), 'unit': 'cm'} 

291 print qa.getvalue(a) 

292 #[3.0, 5.0] 

293 # 

294 

295 

296 -------------------------------------------------------------------------------- 

297 

298 """ 

299 return _quanta.quanta_getvalue(self, *args, **kwargs) 

300 

301 

302 def getunit(self, *args, **kwargs): 

303 """ 

304 getunit(self, _v) -> string 

305 

306 

307 

308 Summary: 

309 get the internal unit of a quantity 

310 

311 Description: 

312 

313 

314 getunit returns the internal unit string of a quantity. Note that 1-D arrays 

315 are supported, but multi-dimensional arrays are not. 

316 

317 Input Parameters: 

318 v quantity 

319 

320 Example: 

321 

322 

323 # 

324 print 't----t getunit Ex 1 t----' 

325 tu = qa.quantity(-1.3, 'Jy') # make quantity 

326 print tu 

327 #{'value': -1.3, 'unit': 'Jy'} 

328 print qa.getvalue(tu) 

329 #-1.3 

330 print qa.getunit(tu) 

331 #Jy 

332 # 

333 

334 

335 -------------------------------------------------------------------------------- 

336 

337 """ 

338 return _quanta.quanta_getunit(self, *args, **kwargs) 

339 

340 

341 def canonical(self, *args, **kwargs): 

342 """ 

343 canonical(self, _v) -> record * 

344 

345 

346 

347 Summary: 

348 get canonical value of quantity 

349 

350 Description: 

351 

352 

353 canonical (with alias canon) gets the canonical value of a quantity 

354 

355 Input Parameters: 

356 v value to convert 

357 

358 Example: 

359 

360 

361 # 

362 print 't----t canonical Ex 1 t----' 

363 print qa.canonical('1Jy')# canonical value of a string 

364 #{'value': 1e-26, 'unit': 'kg.s-2'} 

365 print qa.canon(qa.quantity('1Jy'))# canonical value of a unit 

366 #{'value': 1e-26, 'unit': 'kg.s-2'} 

367 # 

368 

369 

370 -------------------------------------------------------------------------------- 

371 

372 """ 

373 return _quanta.quanta_canonical(self, *args, **kwargs) 

374 

375 

376 def canon(self, *args, **kwargs): 

377 """ 

378 canon(self, _v) -> record * 

379 

380 

381 

382 Summary: 

383 get canonical value of quantity 

384 

385 Description: 

386 

387 

388 canon gets the canonical value of a quantity 

389 

390 Input Parameters: 

391 v value to convert 

392 

393 Example: 

394 

395 

396 # 

397 print 't----t canon Ex 1 t----' 

398 print qa.canon('1Jy') # canonical value of a string 

399 #{'value': 1e-26, 'unit': 'kg.s-2'} 

400 print qa.canonical(qa.quantity('1Jy'))# canonical value of a unit 

401 #{'value': 1e-26, 'unit': 'kg.s-2'} 

402 # 

403 

404 

405 -------------------------------------------------------------------------------- 

406 

407 """ 

408 return _quanta.quanta_canon(self, *args, **kwargs) 

409 

410 

411 def convert(self, *args, **kwargs): 

412 """ 

413 convert(self, _v, _outunit) -> record * 

414 

415 

416 

417 Summary: 

418 convert a quantity to another unit 

419 

420 Description: 

421 

422 

423 convert converts a quantity to another unit. If no output unit given, 

424 conversion is to canonical units 

425 

426 Input Parameters: 

427 v quantity to convert 

428 outunit unit to convert to 

429 

430 Example: 

431 

432 

433 # 

434 print 't----t convert Ex 1 t----' 

435 tu = qa.quantity('5Mm/s')# specify a quantity 

436 print tu 

437 #{'value': 5.0, 'unit': 'Mm/s'} 

438 print qa.convert(tu, 'pc/a')# convert it to parsec per year 

439 #{'value': 0.0051135608266237404, 'unit': 'pc/a'} 

440 print qa.convert(tu)# convert to canonical units 

441 #{'value': 5000000.0, 'unit': 'm.s-1'} 

442 # 

443 

444 

445 -------------------------------------------------------------------------------- 

446 

447 """ 

448 return _quanta.quanta_convert(self, *args, **kwargs) 

449 

450 

451 def define(self, *args, **kwargs): 

452 """ 

453 define(self, _name, _v) -> bool 

454 

455 

456 

457 Summary: 

458 define a new unit name 

459 

460 Description: 

461 

462 

463 define defines the name and value of a user defined unit 

464 

465 Input Parameters: 

466 name name of unit to define 

467 v quantity value of new unit 

468 

469 Example: 

470 

471 

472 # 

473 print 't----t define Ex 1 t----' 

474 print qa.define('JY','1Jy')# your misspelling 

475 #True 

476 print qa.define('VLAunit', '0.898 JY')# a special unit using it 

477 #True 

478 print qa.quantity('5 VLAunit') # check its use 

479 #{'value': 5.0, 'unit': 'VLAunit'} 

480 print qa.convert('5 VLAunit','Jy') 

481 #{'value': 4.4900000000000002, 'unit': 'Jy'} 

482 # 

483 

484 

485 -------------------------------------------------------------------------------- 

486 

487 """ 

488 return _quanta.quanta_define(self, *args, **kwargs) 

489 

490 

491 def map(self, *args, **kwargs): 

492 """ 

493 map(self, _v) -> string 

494 

495 

496 

497 Summary: 

498 list known unit names and constants 

499 

500 Description: 

501 

502 

503 map lists the known mapping of units and constants. It has a single argument, 

504 which can be a coded string (no-case, minimax match): 

505 begin{description} 

506 item[all] all of the following units (not constants): also the default 

507 item[Prefix] known decimal prefixes 

508 item[SI] known SI units 

509 item[Customary] a set of customary units known to programs 

510 item[User] units defined by the user 

511 item[Constants] known constants (note: only 'const', 'Const', 'constants' 

512 and 'Constants' recognised). 

513 end{description} 

514 

515 Input Parameters: 

516 v type of information to list - coded string 

517 

518 Example: 

519 

520 

521 # 

522 print 't----t map Ex 1 t----' 

523 print qa.map('pre')# list decimal prefixes 

524 # == Prefix ==== 20 ==== 

525 # E (exa) 1e+18 

526 # G (giga) 1000000000 

527 # M (mega) 1000000 

528 # P (peta) 1e+15 

529 # T (tera) 1e+12 

530 # Y (yotta) 1e+24 

531 # Z (zetta) 1e+21 

532 # a (atto) 1e-18 

533 # c (centi) 0.01 

534 # d (deci) 0.1 

535 # da (deka) 10 

536 # f (femto) 1e-15 

537 # h (hecto) 100 

538 # k (kilo) 1000 

539 # m (milli) 0.001 

540 # n (nano) 1e-09 

541 # p (pico) 1e-12 

542 # u (micro) 1e-06 

543 # y (yocto) 1e-24 

544 # z (zepto) 1e-21 

545 print qa.map('Constants')# list known constants 

546 # == Constants ==== 

547 # pi 3.14.. 3.14159 

548 # ee 2.71.. 2.71828 

549 # c light vel. 2.99792e+08 m/s 

550 # G grav. const 6.67259e-11 N.m2/kg2 

551 # h Planck const 6.62608e-34 J.s 

552 # HI HI line 1420.41 MHz 

553 # R gas const 8.31451 J/K/mol 

554 # NA Avogadro # 6.02214e+23 mol-1 

555 # e electron charge 1.60218e-19 C 

556 # mp proton mass 1.67262e-27 kg 

557 # mp_me mp/me 1836.15 

558 # mu0 permeability vac. 1.25664e-06 H/m 

559 # eps0 permittivity vac. 1.60218e-19 C 

560 # k Boltzmann const 1.38066e-23 J/K 

561 # F Faraday const 96485.3 C/mol 

562 # me electron mass 9.10939e-31 kg 

563 # re electron radius 2.8179e-15 m 

564 # a0 Bohr's radius 5.2918e-11 m 

565 # R0 solar radius 6.9599e+08 m 

566 # k2 IAU grav. const^2 0.000295912 AU3/d2/S0 

567 # 

568 

569 

570 -------------------------------------------------------------------------------- 

571 

572 """ 

573 return _quanta.quanta_map(self, *args, **kwargs) 

574 

575 

576 def maprec(self, *args, **kwargs): 

577 """ 

578 maprec(self, _v) -> record * 

579 

580 

581 

582 Summary: 

583 create record containing list of known unit names and constants 

584 

585 Description: 

586 

587 

588 maprec returns a record with the known mapping of units and constants. It has a single argument, 

589 which can be a coded string (no-case, minimax match): 

590 begin{description} 

591 item[all] all of the following units (not constants): also the default 

592 item[Prefix] known decimal prefixes 

593 item[SI] known SI units 

594 item[Customary] a set of customary units known to programs 

595 item[User] units defined by the user 

596 end{description} 

597 

598 Input Parameters: 

599 v type of information to list - coded string 

600 

601 Example: 

602 

603 

604 # 

605 print 't----t maprec Ex 1 t----' 

606 p = qa.maprec('pre')# list decimal prefixes 

607 print p['Prefix_G'] 

608 # G (giga) 1000000000 

609 s = qa.maprec('SI') # list SI units 

610 print s['SI_Jy'] 

611 #Jy (jansky) 1e-26 kg.s-2 

612 # 

613 

614 

615 -------------------------------------------------------------------------------- 

616 

617 """ 

618 return _quanta.quanta_maprec(self, *args, **kwargs) 

619 

620 

621 def fits(self): 

622 """ 

623 fits(self) -> bool 

624 

625 

626 

627 Summary: 

628 define some FITS units 

629 

630 Description: 

631 

632 

633 fits defines some unit names used in reading and writing FITS files. 

634 

635 Example: 

636 

637 

638 # 

639 print 't----t fits Ex 1 t----' 

640 print qa.fits() 

641 #True 

642 print qa.map('user') 

643 # == User ==== 

644 # BEAM (dimensionless beam) 1 _ 

645 # DAYS (day) 86400 s 

646 # DEG (degree) 0.0174532925199 rad 

647 # DEGREES (degree) 0.0174532925199 rad 

648 # HZ (hertz) 1 s-1 

649 # JY (jansky) 1e-26 kg.s-2 

650 # KELVIN (kelvin) 1 K 

651 # KELVINS (kelvin) 1 K 

652 # KM (km) 1000 m 

653 # M (meter) 1 m 

654 # METERS (meter) 1 m 

655 # PASCAL (pascal) 1 m-1.kg.s-2 

656 # PIXEL (dimensionless pixel) 1 _ 

657 # S (second) 1 s 

658 # SEC (second) 1 s 

659 # SECONDS (second) 1 s 

660 # VOLTS (volt) 1 m2.kg.s-3.A-1 

661 # YEAR (year) 31557600 s 

662 # YEARS (year) 31557600 s 

663 # 

664 

665 

666 -------------------------------------------------------------------------------- 

667 

668 """ 

669 return _quanta.quanta_fits(self) 

670 

671 

672 def angle(self, *args, **kwargs): 

673 """ 

674 angle(self, _v, _prec, _form, _showform) -> std::vector< std::string > 

675 

676 

677 

678 Summary: 

679 show an angle as a formatted string 

680 

681 Description: 

682 

683 

684 angle converts an angle quantity to a formatted string. The formatting 

685 information is a precision (0 is default, 6 includes +-ddd.mm.ss) and a 

686 string array of codes (no-case, minimax match): 

687 Codes include: 

688 begin{description} 

689 item[clean] delete leading/trailing superfluous separators 

690 item[no_d] do not show degrees part 

691 item[no_dm] do not show degrees and minutes part 

692 item[dig2] show only 2 digits of degrees in angle format 

693 item[time] show as time (hh:mm:ss.ttt) rather than as angle 

694 end{description} 

695 If a multi-dimensional value is given for the value $v$, the returned value 

696 is a string vector of a length equal to last dimension. Each string has a 

697 number of fields equal to the number of elements in all earlier 

698 dimensions. If the {em showform} is $T$, each vector element is surrounded 

699 by a pair of square brackets if there is more than one entry, and fields are 

700 separated by a ','. 

701 

702 Input Parameters: 

703 v angle quantity value to output 

704 prec number of digits shown 

705 form formatting information in coded string array 

706 showform show square brackets and separating , 

707 

708 Example: 

709 

710 

711 # 

712 print 't----t angle Ex 1 t----' 

713 tu = qa.quantity('5.7.12.345678')# define an angle 

714 print tu 

715 #{'value': 5.1200960216666669, 'unit': 'deg'} 

716 print qa.angle(tu) # default output 

717 #+005.07.12 

718 print qa.angle(tu, prec=7)# 7 digits 

719 #+005.07.12.3 

720 print qa.angle(tu, prec=4)# 4 digits 

721 #+005.07. 

722 print qa.angle(tu, form=['tim','no_d'])# as time, no hours shown 

723 #:20:29 

724 # 

725 

726 

727 -------------------------------------------------------------------------------- 

728 

729 """ 

730 return _quanta.quanta_angle(self, *args, **kwargs) 

731 

732 

733 def time(self, *args, **kwargs): 

734 """ 

735 time(self, _v, _prec, _form, _showform) -> std::vector< std::string > 

736 

737 

738 

739 Summary: 

740 show a time (or date) as a formatted string 

741 

742 Description: 

743 

744 

745 time converts a time quantity to a formatted string. The formatting 

746 information is a precision (0 is default, 6 includes hh.mm.ss) and a 

747 string array of codes (no-case, minimax match): 

748 Codes include: 

749 begin{description} 

750 item[clean] delete leading/trailing superfluous separators 

751 item[no_d] do not show hours part 

752 item[no_dm] do not show hours and minutes part 

753 item[ymd] include a date as yyyy/mm/dd (date is by default not shown) 

754 item[dmy] include a date as ddMMMyyyy (date is by default not shown) 

755 item[mjd] include a date as Modified Julian Day (date is by default not shown) 

756 item[fits] include a date and show time in FITS format: le from OS 

757 item[angle] show in angle (dd.mm.ss.ttt) rather than time format 

758 item[day] prefix day-of-week to output 

759 item[local] show local time rather than UTC (add timezone offset) 

760 item[no_time] suppress printing of time part 

761 end{description} 

762 If a multi-dimensional value is given for the value $v$, the returned value 

763 is a string vector of a length equal to last dimension. Each string has a 

764 number of fields equal to the number of elements in all earlier 

765 dimensions. If the {em showform} is $T$, each vector element is surrounded 

766 by a pair of square brackets if there is more than one entry, and fields are 

767 separated by a ','. 

768 

769 Input Parameters: 

770 v time quantity value to output 

771 prec number of digits shown 

772 form formatting information in coded string array 

773 showform show square brackets and separating , 

774 

775 Example: 

776 

777 

778 # 

779 print 't----t time Ex 1 t----' 

780 tu = qa.quantity('today')# a time 

781 print tu 

782 #{'value': 54175.708981504627, 'unit': 'd'} 

783 print qa.time(tu)# default format 

784 #17:00:56 

785 print qa.time(tu,form='dmy') # show date 

786 #16-Mar-2007/17:00:56 

787 print qa.time(tu,form=['ymd','day'])# and day 

788 #Fri-2007/03/16/17:00:56 

789 print qa.time(tu,form='fits') # FITS format 

790 #2007-03-16T17:00:56 

791 print qa.time(tu,form=['fits','local']) # local FITS format 

792 #2007-03-16T10:00:56-07:00 

793 print qa.time(tu,form=['ymd','local']) # local time 

794 #2007/03/16/10:00:56 

795 # 

796 

797 

798 -------------------------------------------------------------------------------- 

799 

800 """ 

801 return _quanta.quanta_time(self, *args, **kwargs) 

802 

803 

804 def add(self, *args, **kwargs): 

805 """ 

806 add(self, _v, _a) -> record * 

807 

808 

809 

810 Summary: 

811 add quantities 

812 

813 Description: 

814 

815 

816 add adds two quantities 

817 

818 Input Parameters: 

819 v value 

820 a value 

821 

822 Example: 

823 

824 

825 # 

826 print 't----t add Ex 1 t----' 

827 print qa.add('5m', '2yd') 

828 #{'value': 6.8288000000000002, 'unit': 'm'} 

829 # 

830 

831 

832 -------------------------------------------------------------------------------- 

833 

834 """ 

835 return _quanta.quanta_add(self, *args, **kwargs) 

836 

837 

838 def sub(self, *args, **kwargs): 

839 """ 

840 sub(self, _v, _a) -> record * 

841 

842 

843 

844 Summary: 

845 subtract quantities 

846 

847 Description: 

848 

849 

850 sub subtracts two quantities 

851 

852 Input Parameters: 

853 v value 

854 a value 

855 

856 Example: 

857 

858 

859 # 

860 print 't----t sub Ex 1 t----' 

861 print qa.sub('5m', '2yd') 

862 #{'value': 3.1712000000000002, 'unit': 'm'} 

863 # 

864 

865 

866 -------------------------------------------------------------------------------- 

867 

868 """ 

869 return _quanta.quanta_sub(self, *args, **kwargs) 

870 

871 

872 def mul(self, *args, **kwargs): 

873 """ 

874 mul(self, _v, _a) -> record * 

875 

876 

877 

878 Summary: 

879 multiply quantities 

880 

881 Description: 

882 

883 

884 mul multiplies two quantities 

885 

886 Input Parameters: 

887 v value 

888 a value 

889 

890 Example: 

891 

892 

893 # 

894 print 't----t mul Ex 1 t----' 

895 print qa.mul('5m', '3s') 

896 #{'value': 15.0, 'unit': 'm.s'} 

897 # 

898 

899 

900 -------------------------------------------------------------------------------- 

901 

902 """ 

903 return _quanta.quanta_mul(self, *args, **kwargs) 

904 

905 

906 def div(self, *args, **kwargs): 

907 """ 

908 div(self, _v, _a) -> record * 

909 

910 

911 

912 Summary: 

913 divides quantities 

914 

915 Description: 

916 

917 

918 div divides two quantities 

919 

920 Input Parameters: 

921 v value 

922 a value 

923 

924 Example: 

925 

926 

927 # 

928 print 't----t div Ex 1 t----' 

929 print qa.div('5m', '3s') 

930 #{'value': 1.6666666666666667, 'unit': 'm/(s)'} 

931 # 

932 

933 

934 -------------------------------------------------------------------------------- 

935 

936 """ 

937 return _quanta.quanta_div(self, *args, **kwargs) 

938 

939 

940 def neg(self, *args, **kwargs): 

941 """ 

942 neg(self, _v) -> record * 

943 

944 

945 

946 Summary: 

947 negate quantities 

948 

949 Description: 

950 

951 

952 neg negates a quantity 

953 

954 Input Parameters: 

955 v value 

956 

957 Example: 

958 

959 

960 # 

961 print 't----t neg Ex 1 t----' 

962 print qa.neg('5m') 

963 #{'value': -5.0, 'unit': 'm'} 

964 # 

965 

966 

967 -------------------------------------------------------------------------------- 

968 

969 """ 

970 return _quanta.quanta_neg(self, *args, **kwargs) 

971 

972 

973 def norm(self, *args, **kwargs): 

974 """ 

975 norm(self, _v, _a) -> record * 

976 

977 

978 

979 Summary: 

980 normalise angle 

981 

982 Description: 

983 

984 

985 norm normalise angles in interval of $2pi$ radians. The default interval is 

986 from -0.5 to +0.5 of a full interval (i.e. from -180 to +180 degrees). The 

987 lower end of the interval can be set as a fraction of $2pi$ 

988 

989 Input Parameters: 

990 v angle quantity 

991 a lower interval boundary 

992 

993 Example: 

994 

995 

996 # 

997 print 't----t norm Ex 1 t----' 

998 print qa.norm('713deg')#default normalisation 

999 #{'value': -6.9999999999999716, 'unit': 'deg'} 

1000 print qa.norm('713deg', -2.5) # normalise to interval -900 - -540 deg 

1001 #{'value': -727.0, 'unit': 'deg'} 

1002 # 

1003 

1004 

1005 -------------------------------------------------------------------------------- 

1006 

1007 """ 

1008 return _quanta.quanta_norm(self, *args, **kwargs) 

1009 

1010 

1011 def le(self, *args, **kwargs): 

1012 """ 

1013 le(self, _v, _a) -> bool 

1014 

1015 

1016 

1017 Summary: 

1018 compare quantities 

1019 

1020 Description: 

1021 

1022 

1023 le compares two quantities for less than or equal. 

1024 

1025 Input Parameters: 

1026 v value 

1027 a value 

1028 

1029 Example: 

1030 

1031 

1032 # 

1033 print 't----t le Ex 1 t----' 

1034 print qa.le('5m', '2yd') 

1035 #False 

1036 # 

1037 

1038 

1039 -------------------------------------------------------------------------------- 

1040 

1041 """ 

1042 return _quanta.quanta_le(self, *args, **kwargs) 

1043 

1044 

1045 def lt(self, *args, **kwargs): 

1046 """ 

1047 lt(self, _v, _a) -> bool 

1048 

1049 

1050 

1051 Summary: 

1052 compare quantities 

1053 

1054 Description: 

1055 

1056 

1057 lt compares two quantities for less than. 

1058 

1059 Input Parameters: 

1060 v value 

1061 a value 

1062 

1063 Example: 

1064 

1065 

1066 # 

1067 print 't----t lt Ex 1 t----' 

1068 print qa.lt('5m', '2yd') 

1069 #False 

1070 # 

1071 

1072 

1073 -------------------------------------------------------------------------------- 

1074 

1075 """ 

1076 return _quanta.quanta_lt(self, *args, **kwargs) 

1077 

1078 

1079 def eq(self, *args, **kwargs): 

1080 """ 

1081 eq(self, _v, _a) -> bool 

1082 

1083 

1084 

1085 Summary: 

1086 compare quantities 

1087 

1088 Description: 

1089 

1090 

1091 eq compares two quantities for equality. 

1092 

1093 Input Parameters: 

1094 v value 

1095 a value 

1096 

1097 Example: 

1098 

1099 

1100 # 

1101 print 't----t eq Ex 1 t----' 

1102 print qa.eq('5m', '2yd') 

1103 #False 

1104 # 

1105 

1106 

1107 -------------------------------------------------------------------------------- 

1108 

1109 """ 

1110 return _quanta.quanta_eq(self, *args, **kwargs) 

1111 

1112 

1113 def ne(self, *args, **kwargs): 

1114 """ 

1115 ne(self, _v, _a) -> bool 

1116 

1117 

1118 

1119 Summary: 

1120 compare quantities 

1121 

1122 Description: 

1123 

1124 

1125 ne compares two quantities for non equality. 

1126 

1127 Input Parameters: 

1128 v value 

1129 a value 

1130 

1131 Example: 

1132 

1133 

1134 # 

1135 print 't----t ne Ex 1 t----' 

1136 print qa.ne('5m', '2yd') 

1137 #True 

1138 # 

1139 

1140 

1141 -------------------------------------------------------------------------------- 

1142 

1143 """ 

1144 return _quanta.quanta_ne(self, *args, **kwargs) 

1145 

1146 

1147 def gt(self, *args, **kwargs): 

1148 """ 

1149 gt(self, _v, _a) -> bool 

1150 

1151 

1152 

1153 Summary: 

1154 compare quantities 

1155 

1156 Description: 

1157 

1158 

1159 gt compares two quantities for greater than. 

1160 

1161 Input Parameters: 

1162 v value 

1163 a value 

1164 

1165 Example: 

1166 

1167 

1168 # 

1169 print 't----t gt Ex 1 t----' 

1170 print qa.gt('5m', '2yd') 

1171 #True 

1172 # 

1173 

1174 

1175 -------------------------------------------------------------------------------- 

1176 

1177 """ 

1178 return _quanta.quanta_gt(self, *args, **kwargs) 

1179 

1180 

1181 def ge(self, *args, **kwargs): 

1182 """ 

1183 ge(self, _v, _a) -> bool 

1184 

1185 

1186 

1187 Summary: 

1188 compare quantities 

1189 

1190 Description: 

1191 

1192 

1193 ge compares two quantities for greater than or equal. 

1194 

1195 Input Parameters: 

1196 v value 

1197 a value 

1198 

1199 Example: 

1200 

1201 

1202 # 

1203 print 't----t ge Ex 1 t----' 

1204 print qa.ge('5m', '2yd') 

1205 #True 

1206 # 

1207 

1208 

1209 -------------------------------------------------------------------------------- 

1210 

1211 """ 

1212 return _quanta.quanta_ge(self, *args, **kwargs) 

1213 

1214 

1215 def sin(self, *args, **kwargs): 

1216 """ 

1217 sin(self, _v) -> record * 

1218 

1219 

1220 

1221 Summary: 

1222 sine of quantity 

1223 

1224 Description: 

1225 

1226 

1227 sin gives sine of angle quantity