KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > javax > measure > units > SI


1 /*
2  * JScience - Java(TM) Tools and Libraries for the Advancement of Sciences.
3  * Copyright (C) 2006 - JScience (http://jscience.org/)
4  * All rights reserved.
5  *
6  * Permission to use, copy, modify, and distribute this software is
7  * freely granted, provided that this notice is preserved.
8  */
9 package javax.measure.units;
10
11 import java.util.Collections JavaDoc;
12 import java.util.HashSet JavaDoc;
13 import java.util.Set JavaDoc;
14
15 import javax.measure.converters.MultiplyConverter;
16 import javax.measure.converters.RationalConverter;
17 import javax.measure.quantities.*;
18
19 /**
20  * <p> This class contains SI (Système International d'Unités) base units,
21  * and derived units.</p>
22  *
23  * <p> It also defines the 20 SI prefixes used to form decimal multiples and
24  * submultiples of SI units. For example:[code]
25  * import static org.jscience.physics.units.SI.*; // Static import.
26  * ...
27  * Unit<Pressure> HECTO_PASCAL = HECTO(PASCAL);
28  * Unit<Length> KILO_METER = KILO(METER);
29  * [/code]</p>
30  *
31  * <p> A collection of all the SI units defined can be retrieved using the
32  * {@link #units() SI.units()} static method.</p>
33  *
34  * @author <a HREF="mailto:jean-marie@dautelle.com">Jean-Marie Dautelle</a>
35  * @version 3.1, April 19, 2006
36  * @see <a HREF="http://en.wikipedia.org/wiki/SI">Wikipedia: SI</a>
37  * @see <a HREF="http://en.wikipedia.org/wiki/SI_prefix">Wikipedia: SI prefix</a>
38  */
39 public final class SI {
40
41     /**
42      * Holds collection of SI units.
43      */
44     private static HashSet JavaDoc<Unit<?>> INSTANCES = new HashSet JavaDoc<Unit<?>>();
45
46     /**
47      * Default constructor (prevents this class from being instantiated).
48      */
49     private SI() {
50     }
51
52     ////////////////
53 // BASE UNITS //
54 ////////////////
55
56     /**
57      * The base unit for electric current quantities (<code>A</code>).
58      * The Ampere is that constant current which, if maintained in two straight
59      * parallel conductors of infinite length, of negligible circular
60      * cross-section, and placed 1 metre apart in vacuum, would produce between
61      * these conductors a force equal to 2 × 10-7 newton per metre of length.
62      * It is named after the French physicist Andre Ampere (1775-1836).
63      */
64     public static final BaseUnit<ElectricCurrent> AMPERE = si(new BaseUnit<ElectricCurrent>(
65             "A"));
66
67     /**
68      * The base unit for luminous intensity quantities (<code>cd</code>).
69      * The candela is the luminous intensity, in a given direction,
70      * of a source that emits monochromatic radiation of frequency
71      * 540 × 1012 hertz and that has a radiant intensity in that
72      * direction of 1/683 watt per steradian
73      * @see <a HREF="http://en.wikipedia.org/wiki/Candela">
74      * Wikipedia: Candela</a>
75      */
76     public static final BaseUnit<LuminousIntensity> CANDELA = si(new BaseUnit<LuminousIntensity>(
77             "cd"));
78
79     /**
80      * The base unit for thermodynamic temperature quantities (<code>K</code>).
81      * The kelvin is the 1/273.16th of the thermodynamic temperature of the
82      * triple point of water. It is named after the Scottish mathematician and
83      * physicist William Thomson 1st Lord Kelvin (1824-1907)
84      */
85     public static final BaseUnit<Temperature> KELVIN = si(new BaseUnit<Temperature>(
86             "K"));
87
88     /**
89      * The base unit for mass quantities (<code>kg</code>).
90      * It is the only SI unit with a prefix as part of its name and symbol.
91      * The kilogram is equal to the mass of an international prototype in the
92      * form of a platinum-iridium cylinder kept at Sevres in France.
93      * @see #GRAM
94      */
95     public static final BaseUnit<Mass> KILOGRAM = si(new BaseUnit<Mass>("kg"));
96
97     /**
98      * The base unit for length quantities (<code>m</code>).
99      * One meter was redefined in 1983 as the distance traveled by light in
100      * a vacuum in 1/299,792,458 of a second.
101      */
102     public static final BaseUnit<Length> METER = si(new BaseUnit<Length>("m"));
103
104     /**
105      * The base unit for amount of substance quantities (<code>mol</code>).
106      * The mole is the amount of substance of a system which contains as many
107      * elementary entities as there are atoms in 0.012 kilogram of carbon 12.
108      */
109     public static final BaseUnit<AmountOfSubstance> MOLE = si(new BaseUnit<AmountOfSubstance>(
110             "mol"));
111
112     /**
113      * The base unit for duration quantities (<code>s</code>).
114      * It is defined as the duration of 9,192,631,770 cycles of radiation
115      * corresponding to the transition between two hyperfine levels of
116      * the ground state of cesium (1967 Standard).
117      */
118     public static final BaseUnit<Duration> SECOND = si(new BaseUnit<Duration>(
119             "s"));
120
121     ////////////////////////////////
122 // SI DERIVED ALTERNATE UNITS //
123 ////////////////////////////////
124
125     /**
126      * The derived unit for mass quantities (<code>g</code>).
127      * The base unit for mass quantity is {@link #KILOGRAM}.
128      */
129     public static final Unit<Mass> GRAM = KILOGRAM.divide(1000);
130
131     /**
132      * The unit for plane angle quantities (<code>rad</code>).
133      * One radian is the angle between two radii of a circle such that the
134      * length of the arc between them is equal to the radius.
135      */
136     public static final AlternateUnit<Angle> RADIAN = si(new AlternateUnit<Angle>(
137             "rad", Unit.ONE));
138
139     /**
140      * The unit for solid angle quantities (<code>sr</code>).
141      * One steradian is the solid angle subtended at the center of a sphere by
142      * an area on the surface of the sphere that is equal to the radius squared.
143      * The total solid angle of a sphere is 4*Pi steradians.
144      */
145     public static final AlternateUnit<SolidAngle> STERADIAN = si(new AlternateUnit<SolidAngle>(
146             "sr", Unit.ONE));
147
148     /**
149      * The unit for binary information (<code>bit</code>).
150      */
151     public static final AlternateUnit<DataAmount> BIT = si(new AlternateUnit<DataAmount>(
152             "bit", Unit.ONE));
153
154     /**
155      * The derived unit for frequency (<code>Hz</code>).
156      * A unit of frequency equal to one cycle per second.
157      * After Heinrich Rudolf Hertz (1857-1894), German physicist who was the
158      * first to produce radio waves artificially.
159      */
160     public static final AlternateUnit<Frequency> HERTZ = si(new AlternateUnit<Frequency>(
161             "Hz", Unit.ONE.divide(SECOND)));
162
163     /**
164      * The derived unit for force (<code>N</code>).
165      * One newton is the force required to give a mass of 1 kilogram an Force
166      * of 1 metre per second per second. It is named after the English
167      * mathematician and physicist Sir Isaac Newton (1642-1727).
168      */
169     public static final AlternateUnit<Force> NEWTON = si(new AlternateUnit<Force>(
170             "N", METER.times(KILOGRAM).divide(SECOND.pow(2))));
171
172     /**
173      * The derived unit for pressure, stress (<code>Pa</code>).
174      * One pascal is equal to one newton per square meter. It is named after
175      * the French philosopher and mathematician Blaise Pascal (1623-1662).
176      */
177     public static final AlternateUnit<Pressure> PASCAL = si(new AlternateUnit<Pressure>(
178             "Pa", NEWTON.divide(METER.pow(2))));
179
180     /**
181      * The derived unit for energy, work, quantity of heat (<code>J</code>).
182      * One joule is the amount of work done when an applied force of 1 newton
183      * moves through a distance of 1 metre in the direction of the force.
184      * It is named after the English physicist James Prescott Joule (1818-1889).
185      */
186     public static final AlternateUnit<Energy> JOULE = si(new AlternateUnit<Energy>(
187             "J", NEWTON.times(METER)));
188
189     /**
190      * The derived unit for power, radiant, flux (<code>W</code>).
191      * One watt is equal to one joule per second. It is named after the British
192      * scientist James Watt (1736-1819).
193      */
194     public static final AlternateUnit<Power> WATT = si(new AlternateUnit<Power>(
195             "W", JOULE.divide(SECOND)));
196
197     /**
198      * The derived unit for electric charge, quantity of electricity
199      * (<code>C</code>).
200      * One Coulomb is equal to the quantity of charge transferred in one second
201      * by a steady current of one ampere. It is named after the French physicist
202      * Charles Augustin de Coulomb (1736-1806).
203      */
204     public static final AlternateUnit<ElectricCharge> COULOMB = si(new AlternateUnit<ElectricCharge>(
205             "C", SECOND.times(AMPERE)));
206
207     /**
208      * The derived unit for electric potential difference, electromotive force
209      * (<code>V</code>).
210      * One Volt is equal to the difference of electric potential between two
211      * points on a conducting wire carrying a constant current of one ampere
212      * when the power dissipated between the points is one watt. It is named
213      * after the Italian physicist Count Alessandro Volta (1745-1827).
214      */
215     public static final AlternateUnit<ElectricPotential> VOLT = si(new AlternateUnit<ElectricPotential>(
216             "V", WATT.divide(AMPERE)));
217
218     /**
219      * The derived unit for capacitance (<code>F</code>).
220      * One Farad is equal to the capacitance of a capacitor having an equal
221      * and opposite charge of 1 coulomb on each plate and a potential difference
222      * of 1 volt between the plates. It is named after the British physicist
223      * and chemist Michael Faraday (1791-1867).
224      */
225     public static final AlternateUnit<ElectricCapacitance> FARAD = si(new AlternateUnit<ElectricCapacitance>(
226             "F", COULOMB.divide(VOLT)));
227
228     /**
229      * The derived unit for electric resistance (<code>Ω</code> or
230      * <code>Ohm</code>).
231      * One Ohm is equal to the resistance of a conductor in which a current of
232      * one ampere is produced by a potential of one volt across its terminals.
233      * It is named after the German physicist Georg Simon Ohm (1789-1854).
234      */
235     public static final AlternateUnit<ElectricResistance> OHM = si(new AlternateUnit<ElectricResistance>(
236             "Ω", VOLT.divide(AMPERE)));
237
238     /**
239      * The derived unit for electric conductance (<code>S</code>).
240      * One Siemens is equal to one ampere per volt. It is named after
241      * the German engineer Ernst Werner von Siemens (1816-1892).
242      */
243     public static final AlternateUnit<ElectricConductance> SIEMENS = si(new AlternateUnit<ElectricConductance>(
244             "S", AMPERE.divide(VOLT)));
245
246     /**
247      * The derived unit for magnetic flux (<code>Wb</code>).
248      * One Weber is equal to the magnetic flux that in linking a circuit of one
249      * turn produces in it an electromotive force of one volt as it is uniformly
250      * reduced to zero within one second. It is named after the German physicist
251      * Wilhelm Eduard Weber (1804-1891).
252      */
253     public static final AlternateUnit<MagneticFlux> WEBER = si(new AlternateUnit<MagneticFlux>(
254             "Wb", VOLT.times(SECOND)));
255
256     /**
257      * The derived unit for magnetic flux density (<code>T</code>).
258      * One Tesla is equal equal to one weber per square meter. It is named
259      * after the Serbian-born American electrical engineer and physicist
260      * Nikola Tesla (1856-1943).
261      */
262     public static final AlternateUnit<MagneticFluxDensity> TESLA = si(new AlternateUnit<MagneticFluxDensity>(
263             "T", WEBER.divide(METER.pow(2))));
264
265     /**
266      * The derived unit for inductance (<code>H</code>).
267      * One Henry is equal to the inductance for which an induced electromotive
268      * force of one volt is produced when the current is varied at the rate of
269      * one ampere per second. It is named after the American physicist
270      * Joseph Henry (1791-1878).
271      */
272     public static final AlternateUnit<ElectricInductance> HENRY = si(new AlternateUnit<ElectricInductance>(
273             "H", WEBER.divide(AMPERE)));
274
275     /**
276      * The derived unit for Celsius temperature (<code>°C</code>).
277      * This is a unit of temperature such as the freezing point of water
278      * (at one atmosphere of pressure) is 0 °C, while the boiling point is
279      * 100 °C.
280      */
281     public static final Unit<Temperature> CELSIUS = si(KELVIN.plus(273.15));
282
283     /**
284      * The derived unit for luminous flux (<code>lm</code>).
285      * One Lumen is equal to the amount of light given out through a solid angle
286      * by a source of one candela intensity radiating equally in all directions.
287      */
288     public static final AlternateUnit<LuminousFlux> LUMEN = si(new AlternateUnit<LuminousFlux>(
289             "lm", CANDELA.times(STERADIAN)));
290
291     /**
292      * The derived unit for illuminance (<code>lx</code>).
293      * One Lux is equal to one lumen per square meter.
294      */
295     public static final AlternateUnit<Illuminance> LUX = si(new AlternateUnit<Illuminance>(
296             "lx", LUMEN.divide(METER.pow(2))));
297
298     /**
299      * The derived unit for activity of a radionuclide (<code>Bq</code>).
300      * One becquerel is the radiation caused by one disintegration per second.
301      * It is named after the French physicist, Antoine-Henri Becquerel
302      * (1852-1908).
303      */
304     public static final AlternateUnit<RadioactiveActivity> BECQUEREL = si(new AlternateUnit<RadioactiveActivity>(
305             "Bq", Unit.ONE.divide(SECOND)));
306
307     /**
308      * The derived unit for absorbed dose, specific energy (imparted), kerma
309      * (<code>Gy</code>).
310      * One gray is equal to the dose of one joule of energy absorbed per one
311      * kilogram of matter. It is named after the British physician
312      * L. H. Gray (1905-1965).
313      */
314     public static final AlternateUnit<RadiationDoseAbsorbed> GRAY = si(new AlternateUnit<RadiationDoseAbsorbed>(
315             "Gy", JOULE.divide(KILOGRAM)));
316
317     /**
318      * The derived unit for dose equivalent (<code>Sv</code>).
319      * One Sievert is equal is equal to the actual dose, in grays, multiplied
320      * by a "quality factor" which is larger for more dangerous forms of
321      * radiation. It is named after the Swedish physicist Rolf Sievert
322      * (1898-1966).
323      */
324     public static final AlternateUnit<RadiationDoseEffective> SIEVERT = si(new AlternateUnit<RadiationDoseEffective>(
325             "Sv", JOULE.divide(KILOGRAM)));
326
327     /**
328      * The derived unit for catalytic activity (<code>kat</code>).
329      */
330     public static final AlternateUnit<CatalyticActivity> KATAL = si(new AlternateUnit<CatalyticActivity>(
331             "kat", MOLE.divide(SECOND)));
332
333     //////////////////////////////
334 // SI DERIVED PRODUCT UNITS //
335 //////////////////////////////
336
337     /**
338      * The metric unit for velocity quantities (<code>m/s</code>).
339      */
340     public static final Unit<Velocity> METER_PER_SECOND
341         = si(new ProductUnit<Velocity>(METER.divide(SECOND)));
342
343     /**
344      * The metric unit for acceleration quantities (<code>m/s²</code>).
345      */
346     public static final Unit<Acceleration> METER_PER_SQUARE_SECOND
347        = si(new ProductUnit<Acceleration>(METER_PER_SECOND.divide(SECOND)));
348
349     /**
350      * The metric unit for area quantities (<code>m²</code>).
351      */
352     public static final Unit<Area> SQUARE_METER =
353         si(new ProductUnit<Area>(METER.times(METER)));
354
355     /**
356      * The metric unit for volume quantities (<code>m³</code>).
357      */
358     public static final Unit<Volume> CUBIC_METER
359        = si(new ProductUnit<Volume>(SQUARE_METER.times(METER)));
360
361     /////////////////
362 // SI PREFIXES //
363 /////////////////
364
365     /**
366      * Returns the specified unit multiplied by the factor
367      * <code>10<sup>24</sup></code>
368      *
369      * @param unit any unit.
370      * @return <code>unit.multiply(1e24)</code>.
371      */
372     public static <Q extends Quantity> Unit<Q> YOTTA(Unit<Q> unit) {
373         return unit.transform(E24);
374     }
375
376     /**
377      * Returns the specified unit multiplied by the factor
378      * <code>10<sup>21</sup></code>
379      *
380      * @param unit any unit.
381      * @return <code>unit.multiply(1e21)</code>.
382      */
383     public static <Q extends Quantity> Unit<Q> ZETTA(Unit<Q> unit) {
384         return unit.transform(E21);
385     }
386
387     /**
388      * Returns the specified unit multiplied by the factor
389      * <code>10<sup>18</sup></code>
390      *
391      * @param unit any unit.
392      * @return <code>unit.multiply(1e18)</code>.
393      */
394     public static <Q extends Quantity> Unit<Q> EXA(Unit<Q> unit) {
395         return unit.transform(E18);
396     }
397
398     /**
399      * Returns the specified unit multiplied by the factor
400      * <code>10<sup>15</sup></code>
401      *
402      * @param unit any unit.
403      * @return <code>unit.multiply(1e15)</code>.
404      */
405     public static <Q extends Quantity> Unit<Q> PETA(Unit<Q> unit) {
406         return unit.transform(E15);
407     }
408
409     /**
410      * Returns the specified unit multiplied by the factor
411      * <code>10<sup>12</sup></code>
412      *
413      * @param unit any unit.
414      * @return <code>unit.multiply(1e12)</code>.
415      */
416     public static <Q extends Quantity> Unit<Q> TERA(Unit<Q> unit) {
417         return unit.transform(E12);
418     }
419
420     /**
421      * Returns the specified unit multiplied by the factor
422      * <code>10<sup>9</sup></code>
423      *
424      * @param unit any unit.
425      * @return <code>unit.multiply(1e9)</code>.
426      */
427     public static <Q extends Quantity> Unit<Q> GIGA(Unit<Q> unit) {
428         return unit.transform(E9);
429     }
430
431     /**
432      * Returns the specified unit multiplied by the factor
433      * <code>10<sup>6</sup></code>
434      *
435      * @param unit any unit.
436      * @return <code>unit.multiply(1e6)</code>.
437      */
438     public static <Q extends Quantity> Unit<Q> MEGA(Unit<Q> unit) {
439         return unit.transform(E6);
440     }
441
442     /**
443      * Returns the specified unit multiplied by the factor
444      * <code>10<sup>3</sup></code>
445      *
446      * @param unit any unit.
447      * @return <code>unit.multiply(1e3)</code>.
448      */
449     public static <Q extends Quantity> Unit<Q> KILO(Unit<Q> unit) {
450         return unit.transform(E3);
451     }
452
453     /**
454      * Returns the specified unit multiplied by the factor
455      * <code>10<sup>2</sup></code>
456      *
457      * @param unit any unit.
458      * @return <code>unit.multiply(1e2)</code>.
459      */
460     public static <Q extends Quantity> Unit<Q> HECTO(Unit<Q> unit) {
461         return unit.transform(E2);
462     }
463
464     /**
465      * Returns the specified unit multiplied by the factor
466      * <code>10<sup>1</sup></code>
467      *
468      * @param unit any unit.
469      * @return <code>unit.multiply(1e1)</code>.
470      */
471     public static <Q extends Quantity> Unit<Q> DEKA(Unit<Q> unit) {
472         return unit.transform(E1);
473     }
474
475     /**
476      * Returns the specified unit multiplied by the factor
477      * <code>10<sup>-1</sup></code>
478      *
479      * @param unit any unit.
480      * @return <code>unit.multiply(1e-1)</code>.
481      */
482     public static <Q extends Quantity> Unit<Q> DECI(Unit<Q> unit) {
483         return unit.transform(Em1);
484     }
485
486     /**
487      * Returns the specified unit multiplied by the factor
488      * <code>10<sup>-2</sup></code>
489      *
490      * @param unit any unit.
491      * @return <code>unit.multiply(1e-2)</code>.
492      */
493     public static <Q extends Quantity> Unit<Q> CENTI(Unit<Q> unit) {
494         return unit.transform(Em2);
495     }
496
497     /**
498      * Returns the specified unit multiplied by the factor
499      * <code>10<sup>-3</sup></code>
500      *
501      * @param unit any unit.
502      * @return <code>unit.multiply(1e-3)</code>.
503      */
504     public static <Q extends Quantity> Unit<Q> MILLI(Unit<Q> unit) {
505         return unit.transform(Em3);
506     }
507
508     /**
509      * Returns the specified unit multiplied by the factor
510      * <code>10<sup>-6</sup></code>
511      *
512      * @param unit any unit.
513      * @return <code>unit.multiply(1e-6)</code>.
514      */
515     public static <Q extends Quantity> Unit<Q> MICRO(Unit<Q> unit) {
516         return unit.transform(Em6);
517     }
518
519     /**
520      * Returns the specified unit multiplied by the factor
521      * <code>10<sup>-9</sup></code>
522      *
523      * @param unit any unit.
524      * @return <code>unit.multiply(1e-9)</code>.
525      */
526     public static <Q extends Quantity> Unit<Q> NANO(Unit<Q> unit) {
527         return unit.transform(Em9);
528     }
529
530     /**
531      * Returns the specified unit multiplied by the factor
532      * <code>10<sup>-12</sup></code>
533      *
534      * @param unit any unit.
535      * @return <code>unit.multiply(1e-12)</code>.
536      */
537     public static <Q extends Quantity> Unit<Q> PICO(Unit<Q> unit) {
538         return unit.transform(Em12);
539     }
540
541     /**
542      * Returns the specified unit multiplied by the factor
543      * <code>10<sup>-15</sup></code>
544      *
545      * @param unit any unit.
546      * @return <code>unit.multiply(1e-15)</code>.
547      */
548     public static <Q extends Quantity> Unit<Q> FEMTO(Unit<Q> unit) {
549         return unit.transform(Em15);
550     }
551
552     /**
553      * Returns the specified unit multiplied by the factor
554      * <code>10<sup>-18</sup></code>
555      *
556      * @param unit any unit.
557      * @return <code>unit.multiply(1e-18)</code>.
558      */
559     public static <Q extends Quantity> Unit<Q> ATTO(Unit<Q> unit) {
560         return unit.transform(Em18);
561     }
562
563     /**
564      * Returns the specified unit multiplied by the factor
565      * <code>10<sup>-21</sup></code>
566      *
567      * @param unit any unit.
568      * @return <code>unit.multiply(1e-21)</code>.
569      */
570     public static <Q extends Quantity> Unit<Q> ZEPTO(Unit<Q> unit) {
571         return unit.transform(Em21);
572     }
573
574     /**
575      * Returns the specified unit multiplied by the factor
576      * <code>10<sup>-24</sup></code>
577      *
578      * @param unit any unit.
579      * @return <code>unit.multiply(1e-24)</code>.
580      */
581     public static <Q extends Quantity> Unit<Q> YOCTO(Unit<Q> unit) {
582         return unit.transform(Em24);
583     }
584
585     /////////////////////
586 // Collection View //
587 /////////////////////
588
589     /**
590      * Returns a read only view over the SI units defined in this class.
591      *
592      * @return the collection of SI units.
593      */
594     public static Set JavaDoc<Unit<?>> units() {
595         return Collections.unmodifiableSet(INSTANCES);
596     }
597
598     /**
599      * Adds a new unit to the collection.
600      *
601      * @param unit the unit being added.
602      * @return <code>unit</code>.
603      */
604     private static <U extends Unit> U si(U unit) {
605         INSTANCES.add(unit);
606         return unit;
607     }
608
609     // Holds prefix converters (optimization).
610
611     static final MultiplyConverter E24 = new MultiplyConverter(1E24);
612
613     static final MultiplyConverter E21 = new MultiplyConverter(1E21);
614
615     static final RationalConverter E18 = new RationalConverter(
616             1000000000000000000L, 1);
617
618     static final RationalConverter E15 = new RationalConverter(
619             1000000000000000L, 1);
620
621     static final RationalConverter E12 = new RationalConverter(1000000000000L,
622             1);
623
624     static final RationalConverter E9 = new RationalConverter(1000000000L, 1);
625
626     static final RationalConverter E6 = new RationalConverter(1000000L, 1);
627
628     static final RationalConverter E3 = new RationalConverter(1000L, 1);
629
630     static final RationalConverter E2 = new RationalConverter(100L, 1);
631
632     static final RationalConverter E1 = new RationalConverter(10L, 1);
633
634     static final RationalConverter Em1 = new RationalConverter(1, 10L);
635
636     static final RationalConverter Em2 = new RationalConverter(1, 100L);
637
638     static final RationalConverter Em3 = new RationalConverter(1, 1000L);
639
640     static final RationalConverter Em6 = new RationalConverter(1, 1000000L);
641
642     static final RationalConverter Em9 = new RationalConverter(1, 1000000000L);
643
644     static final RationalConverter Em12 = new RationalConverter(1,
645             1000000000000L);
646
647     static final RationalConverter Em15 = new RationalConverter(1,
648             1000000000000000L);
649
650     static final RationalConverter Em18 = new RationalConverter(1,
651             1000000000000000000L);
652
653     static final MultiplyConverter Em21 = new MultiplyConverter(1E-21);
654
655     static final MultiplyConverter Em24 = new MultiplyConverter(1E-24);
656 }
Popular Tags