[READ-ONLY] Mirror of https://github.com/probablykasper/cpc. Text calculator with support for units and conversion
cpc.kasper.space
calculator
cli
conversion
converter
library
math
package
units
units-converter
wasm
website
Fix weights
+165
-226
+165
-226
src/units.rs
+165
-226
src/units.rs
···
44
44
impl UnitType {
45
45
fn primitive(&self) -> Vec<(Unit, isize)> {
46
46
match self {
47
-
// Time => vec![(Time, 1)],
48
-
// Length => vec![(Length, 1)],
49
-
// Area => vec![(Length, 2)],
50
-
// Volume => vec![(Length, 3)],
51
-
// Mass => vec![(Mass, 1)],
52
-
// DigitalStorage => vec![(DigitalStorage, 1)],
53
-
// DataTransferRate => vec![(DigitalStorage, 1), (Time, -1)],
54
-
// FlopCount => vec![(FlopCount, 1)],
55
-
// FlopRate => vec![(FlopCount, 1), (Time, -1)],
56
-
// Energy => vec![(Mass, 1), (Length, 2), (Time, -2)],
57
-
// Power => vec![(Mass, 1), (Length, 2), (Time, -3)],
58
-
// ElectricCurrent => vec![(ElectricCurrent, 1)],
59
-
// Resistance => vec![(Mass, 1), (Length, 2), (Time, -3), (ElectricCurrent, -2)],
60
-
// Voltage => vec![(Mass, 1), (Length, 2), (Time, -3), (ElectricCurrent, -1)],
61
-
// Pressure => vec![(Mass, 1), (Length, -1), (Time, -2)],
62
-
// Frequency => vec![(Time, -1)],
63
-
// Speed => vec![(Length, 1), (Time, -1)],
64
-
// Temperature => vec![(Temperature, 1)],
65
-
Time => vec![(Nanosecond, 1)],
66
-
Length => vec![(Millimeter, 1)],
67
-
Area => vec![(Millimeter, 2)],
68
-
Volume => vec![(Millimeter, 3)],
69
-
Mass => vec![(Gram, 1)],
47
+
Time => vec![(Second, 1)],
48
+
Length => vec![(Meter, 1)],
49
+
Area => vec![(Meter, 2)],
50
+
Volume => vec![(Meter, 3)],
51
+
Mass => vec![(Kilogram, 1)],
70
52
DigitalStorage => vec![(Bit, 1)],
71
-
DataTransferRate => vec![(Bit, 1), (Nanosecond, -1)],
53
+
DataTransferRate => vec![(Bit, 1), (Second, -1)],
72
54
FlopCount => vec![(Flop, 1)],
73
-
FlopRate => vec![(Flop, 1), (Nanosecond, -1)],
74
-
Energy => vec![(Gram, 1), (SquareMillimeter, 2), (Nanosecond, -2)],
75
-
Power => vec![(Gram, 1), (SquareMillimeter, 2), (Nanosecond, -3)],
55
+
FlopRate => vec![(Flop, 1), (Second, -1)],
56
+
Energy => vec![(Kilogram, 1), (Meter, 2), (Second, -2)],
57
+
Power => vec![(Kilogram, 1), (Meter, 2), (Second, -3)],
76
58
ElectricCurrent => vec![(Ampere, 1)],
77
-
Resistance => vec![
78
-
(Gram, 1),
79
-
(SquareMillimeter, 2),
80
-
(Nanosecond, -3),
81
-
(Ampere, -2),
82
-
],
83
-
Voltage => vec![
84
-
(Gram, 1),
85
-
(SquareMillimeter, 2),
86
-
(Nanosecond, -3),
87
-
(Ampere, -1),
88
-
],
89
-
Pressure => vec![(Gram, 1), (Millimeter, -1), (Nanosecond, -2)],
90
-
Frequency => vec![(Nanosecond, -1)],
91
-
Speed => vec![(Millimeter, 1), (Nanosecond, -1)],
59
+
Resistance => vec![(Kilogram, 1), (Meter, 2), (Second, -3), (Ampere, -2)],
60
+
Voltage => vec![(Kilogram, 1), (Meter, 2), (Second, -3), (Ampere, -1)],
61
+
Pressure => vec![(Kilogram, 1), (Meter, -1), (Second, -2)],
62
+
Frequency => vec![(Second, -1)],
63
+
Speed => vec![(Meter, 1), (Second, -1)],
92
64
Temperature => vec![(Kelvin, 1)],
93
65
}
94
66
}
···
156
128
}
157
129
158
130
create_units!(
159
-
Nanosecond: (Time, d!(1), "nanosecond", "nanoseconds"),
160
-
Microsecond: (Time, d!(1000), "microsecond", "microseconds"),
161
-
Millisecond: (Time, d!(1000000), "millisecond", "milliseconds"),
162
-
Second: (Time, d!(1000000000), "second", "seconds"),
163
-
Minute: (Time, d!(60000000000), "minute", "minutes"),
164
-
Hour: (Time, d!(3600000000000), "hour", "hours"),
165
-
Day: (Time, d!(86400000000000), "day", "days"),
166
-
Week: (Time, d!(604800000000000), "week", "weeks"),
167
-
Month: (Time, d!(2629746000000000), "month", "months"),
168
-
Quarter: (Time, d!(7889238000000000), "quarter", "quarters"),
169
-
Year: (Time, d!(31556952000000000), "year", "years"),
170
-
Decade: (Time, d!(315569520000000000), "decade", "decades"),
171
-
Century: (Time, d!(3155695200000000000), "century", "centuries"),
172
-
Millennium: (Time, d!(31556952000000000000), "millennium", "millennia"),
131
+
Nanosecond: (Time, d!(0.000000001), "nanosecond", "nanoseconds"),
132
+
Microsecond: (Time, d!(0.000001), "microsecond", "microseconds"),
133
+
Millisecond: (Time, d!(0.001), "millisecond", "milliseconds"),
134
+
Second: (Time, d!(1), "second", "seconds"),
135
+
Minute: (Time, d!(60), "minute", "minutes"),
136
+
Hour: (Time, d!(3600), "hour", "hours"),
137
+
Day: (Time, d!(86400), "day", "days"),
138
+
Week: (Time, d!(604800), "week", "weeks"),
139
+
Month: (Time, d!(2629746), "month", "months"),
140
+
Quarter: (Time, d!(7889238), "quarter", "quarters"),
141
+
Year: (Time, d!(31556952), "year", "years"),
142
+
Decade: (Time, d!(315569520), "decade", "decades"),
143
+
Century: (Time, d!(3155695200), "century", "centuries"),
144
+
Millennium: (Time, d!(31556952000), "millennium", "millennia"),
173
145
174
-
Millimeter: (Length, d!(1), "millimeter", "millimeters"),
175
-
Centimeter: (Length, d!(10), "centimeter", "centimeters"),
176
-
Decimeter: (Length, d!(100), "decimeter", "decimeters"),
177
-
Meter: (Length, d!(1000), "meter", "meters"),
178
-
Kilometer: (Length, d!(1000000), "kilometer", "kilometers"),
179
-
Inch: (Length, d!(25.4), "inch", "inches"),
180
-
Foot: (Length, d!(304.8), "foot", "feet"),
181
-
Yard: (Length, d!(914.4), "yard", "yards"),
182
-
Mile: (Length, d!(1609344), "mile", "miles"),
146
+
Millimeter: (Length, d!(0.001), "millimeter", "millimeters"),
147
+
Centimeter: (Length, d!(0.01), "centimeter", "centimeters"),
148
+
Decimeter: (Length, d!(0.1), "decimeter", "decimeters"),
149
+
Meter: (Length, d!(1), "meter", "meters"),
150
+
Kilometer: (Length, d!(1000), "kilometer", "kilometers"),
151
+
Inch: (Length, d!(0.0254), "inch", "inches"),
152
+
Foot: (Length, d!(0.3048), "foot", "feet"),
153
+
Yard: (Length, d!(0.9144), "yard", "yards"),
154
+
Mile: (Length, d!(1609.344), "mile", "miles"),
183
155
// 1-dimensional only:
184
-
Marathon: (Length, d!(42195000), "marathon", "marathons"),
185
-
NauticalMile: (Length, d!(1852000), "nautical mile", "nautical miles"),
186
-
LightYear: (Length, d!(9460730472580800000), "light year", "light years"),
187
-
LightSecond: (Length, d!(299792458000), "light second", "light seconds"),
156
+
Marathon: (Length, d!(42195), "marathon", "marathons"),
157
+
NauticalMile: (Length, d!(1852), "nautical mile", "nautical miles"),
158
+
LightYear: (Length, d!(9460730472580800), "light year", "light years"),
159
+
LightSecond: (Length, d!(299792458), "light second", "light seconds"),
188
160
189
-
SquareMillimeter: (Area, d!(1), "square millimeter", "square millimeters"),
190
-
SquareCentimeter: (Area, d!(100), "square centimeter", "square centimeters"),
191
-
SquareDecimeter: (Area, d!(10000), "square decimeter", "square decimeters"),
192
-
SquareMeter: (Area, d!(1000000), "square meter", "square meters"),
193
-
SquareKilometer: (Area, d!(1000000000000), "square kilometer", "square kilometers"),
194
-
SquareInch: (Area, d!(645.16), "square inch", "square inches"),
195
-
SquareFoot: (Area, d!(92903.04), "square foot", "square feet"),
196
-
SquareYard: (Area, d!(836127.36), "square yard", "square yards"),
197
-
SquareMile: (Area, d!(2589988110336.00), "square mile", "square miles"),
161
+
SquareMillimeter: (Area, d!(0.000001), "square millimeter", "square millimeters"),
162
+
SquareCentimeter: (Area, d!(0.0001), "square centimeter", "square centimeters"),
163
+
SquareDecimeter: (Area, d!(0.01), "square decimeter", "square decimeters"),
164
+
SquareMeter: (Area, d!(1), "square meter", "square meters"),
165
+
SquareKilometer: (Area, d!(1000000), "square kilometer", "square kilometers"),
166
+
SquareInch: (Area, d!(0.00064516), "square inch", "square inches"),
167
+
SquareFoot: (Area, d!(0.09290304), "square foot", "square feet"),
168
+
SquareYard: (Area, d!(0.83612736), "square yard", "square yards"),
169
+
SquareMile: (Area, d!(2589988.110336), "square mile", "square miles"),
198
170
// 2-dimensional only
199
-
Are: (Area, d!(100000000), "are", "ares"),
200
-
Decare: (Area, d!(1000000000), "decare", "decares"),
201
-
Hectare: (Area, d!(10000000000), "hectare", "hectares"),
202
-
Acre: (Area, d!(4046856422.40), "acre", "acres"),
171
+
Are: (Area, d!(100), "are", "ares"),
172
+
Decare: (Area, d!(1000), "decare", "decares"),
173
+
Hectare: (Area, d!(10000), "hectare", "hectares"),
174
+
Acre: (Area, d!(4046.8564224), "acre", "acres"),
203
175
204
-
CubicMillimeter: (Volume, d!(1), "cubic millimeter", "cubic millimeters"),
205
-
CubicCentimeter: (Volume, d!(1000), "cubic centimeter", "cubic centimeters"),
206
-
CubicDecimeter: (Volume, d!(1000000), "cubic decimeter", "cubic decimeters"),
207
-
CubicMeter: (Volume, d!(1000000000), "cubic meter", "cubic meters"),
208
-
CubicKilometer: (Volume, d!(1000000000000000000), "cubic kilometer", "cubic kilometers"),
209
-
CubicInch: (Volume, d!(16387.064), "cubic inch", "cubic inches"),
210
-
CubicFoot: (Volume, d!(28316846.592), "cubic foot", "cubic feet"),
211
-
CubicYard: (Volume, d!(764554857.984), "cubic yard", "cubic yards"),
212
-
CubicMile: (Volume, d!(4168181825440579584), "cubic mile", "cubic miles"),
176
+
CubicMillimeter: (Volume, d!(0.000000001), "cubic millimeter", "cubic millimeters"),
177
+
CubicCentimeter: (Volume, d!(0.000001), "cubic centimeter", "cubic centimeters"),
178
+
CubicDecimeter: (Volume, d!(0.001), "cubic decimeter", "cubic decimeters"),
179
+
CubicMeter: (Volume, d!(1), "cubic meter", "cubic meters"),
180
+
CubicKilometer: (Volume, d!(1000000000), "cubic kilometer", "cubic kilometers"),
181
+
CubicInch: (Volume, d!(0.000016387064), "cubic inch", "cubic inches"),
182
+
CubicFoot: (Volume, d!(0.028316846592), "cubic foot", "cubic feet"),
183
+
CubicYard: (Volume, d!(0.764554857984), "cubic yard", "cubic yards"),
184
+
CubicMile: (Volume, d!(4168181825.440579584), "cubic mile", "cubic miles"),
213
185
// 3-dimensional only
214
-
Milliliter: (Volume, d!(1000), "milliliter", "milliliters"),
215
-
Centiliter: (Volume, d!(10000), "centiliter", "centiliters"),
216
-
Deciliter: (Volume, d!(100000), "deciliter", "deciliters"),
217
-
Liter: (Volume, d!(1000000), "liter", "liters"),
218
-
Teaspoon: (Volume, d!(4928.92159375), "teaspoon", "teaspoons"),
219
-
Tablespoon: (Volume, d!(14786.76478125), "tablespoon", "tablespoons"),
220
-
FluidOunce: (Volume, d!(29573.5295625), "fluid ounce", "fluid ounces"),
221
-
Cup: (Volume, d!(236588.2365), "cup", "cups"),
222
-
Pint: (Volume, d!(473176.473), "pint", "pints"),
223
-
Quart: (Volume, d!(946352.946), "quart", "quarts"),
224
-
Gallon: (Volume, d!(3785411.784), "gallon", "gallons"),
225
-
OilBarrel: (Volume, d!(158987294.928), "oil barrel", "oil barrels"),
186
+
Milliliter: (Volume, d!(0.000001), "milliliter", "milliliters"),
187
+
Centiliter: (Volume, d!(0.00001), "centiliter", "centiliters"),
188
+
Deciliter: (Volume, d!(0.0001), "deciliter", "deciliters"),
189
+
Liter: (Volume, d!(0.001), "liter", "liters"),
190
+
Teaspoon: (Volume, d!(0.00000492892159375), "teaspoon", "teaspoons"),
191
+
Tablespoon: (Volume, d!(0.00001478676478125), "tablespoon", "tablespoons"),
192
+
FluidOunce: (Volume, d!(0.0000295735295625), "fluid ounce", "fluid ounces"),
193
+
Cup: (Volume, d!(0.0002365882365), "cup", "cups"),
194
+
Pint: (Volume, d!(0.000473176473), "pint", "pints"),
195
+
Quart: (Volume, d!(0.000946352946), "quart", "quarts"),
196
+
Gallon: (Volume, d!(0.003785411784), "gallon", "gallons"),
197
+
OilBarrel: (Volume, d!(0.158987294928), "oil barrel", "oil barrels"),
226
198
227
-
Milligram: (Mass, d!(0.001), "milligram", "milligrams"),
228
-
Gram: (Mass, d!(1), "gram", "grams"),
229
-
Hectogram: (Mass, d!(100), "hectogram", "hectograms"),
230
-
Kilogram: (Mass, d!(1000), "kilogram", "kilograms"),
231
-
MetricTon: (Mass, d!(1000000), "metric ton", "metric tons"),
232
-
Ounce: (Mass, d!(28.349523125), "ounce", "ounces"),
233
-
Pound: (Mass, d!(453.59237), "pound", "pounds"),
234
-
Stone: (Mass, d!(6350.29318), "stone", "stones"),
235
-
ShortTon: (Mass, d!(907184.74), "short ton", "short tons"),
236
-
LongTon: (Mass, d!(1016046.9088), "long ton", "long tons"),
199
+
Milligram: (Mass, d!(0.000001), "milligram", "milligrams"),
200
+
Gram: (Mass, d!(0.001), "gram", "grams"),
201
+
Hectogram: (Mass, d!(0.1), "hectogram", "hectograms"),
202
+
Kilogram: (Mass, d!(1), "kilogram", "kilograms"),
203
+
MetricTon: (Mass, d!(1000), "metric ton", "metric tons"),
204
+
Ounce: (Mass, d!(0.028349523125), "ounce", "ounces"),
205
+
Pound: (Mass, d!(0.45359237), "pound", "pounds"),
206
+
Stone: (Mass, d!(6.35029318), "stone", "stones"),
207
+
ShortTon: (Mass, d!(907.18474), "short ton", "short tons"),
208
+
LongTon: (Mass, d!(1016.0469088), "long ton", "long tons"),
237
209
238
210
Bit: (DigitalStorage, d!(1), "bit", "bits"),
239
211
Kilobit: (DigitalStorage, d!(1000), "kilobit", "kilobits"),
···
356
328
// inexact:
357
329
BritishThermalUnitsPerMinute: (Power, d!(17.584264210333), "british thermal unit per minute", "british thermal units per minute"),
358
330
// inexact:
359
-
BritishThermalUnitsPerHour: (Power, d!(0.29307107017222), "british thermal unit per hour", "british thermal units per hour"), // exact according to wikipedia:
331
+
BritishThermalUnitsPerHour: (Power, d!(0.29307107017222), "british thermal unit per hour", "british thermal units per hour"),
332
+
// exact according to wikipedia:
360
333
Horsepower: (Power, d!(745.69987158227022), "horsepower", "horsepower"),
361
334
MetricHorsepower: (Power, d!(735.49875), "metric horsepower", "metric horsepower"),
362
335
···
392
365
Petahertz: (Frequency, d!(1000000000000000), "petahertz", "petahertz"),
393
366
RevolutionsPerMinute: (Frequency, d!(60), "revolution per minute", "revolutions per minute"),
394
367
395
-
KilometersPerHour: (Speed, d!(1), "kilometer per hour", "kilometers per hour"),
396
-
MetersPerSecond: (Speed, d!(3.6), "meter per second", "meters per second"),
397
-
MilesPerHour: (Speed, d!(1.609344), "mile per hour", "miles per hour"),
398
-
FeetPerSecond: (Speed, d!(1.09728), "foot per second", "feet per second"),
399
-
Knot: (Speed, d!(1.852), "knot", "knots"),
368
+
// inexact:
369
+
KilometersPerHour: (Speed, d!(0.2777777778), "kilometer per hour", "kilometers per hour"),
370
+
MetersPerSecond: (Speed, d!(1), "meter per second", "meters per second"),
371
+
MilesPerHour: (Speed, d!(0.44704), "mile per hour", "miles per hour"),
372
+
FeetPerSecond: (Speed, d!(0.3048), "foot per second", "feet per second"),
373
+
// inexact:
374
+
Knot: (Speed, d!(0.5144444444), "knot", "knots"),
400
375
401
376
Kelvin: (Temperature, d!(0), "kelvin", "kelvin"),
402
377
Celsius: (Temperature, d!(0), "celsius", "celsius"),
···
522
497
let value = number.value * combined_weight(&number.unit);
523
498
let primitive = number.primitive_unit();
524
499
if primitive == Length.primitive() {
525
-
if value >= d!(1000000000000000000) {
526
-
// ≈ 0.1 light years
500
+
if value >= 0.1 * LightYear.weight() {
527
501
return Number::with_basic_unit(value / LightYear.weight(), LightYear);
528
-
} else if value >= d!(1000000) {
529
-
// 1 km
502
+
} else if value >= Kilometer.weight() {
530
503
return Number::with_basic_unit(value / Kilometer.weight(), Kilometer);
531
-
} else if value >= d!(1000) {
532
-
// 1 m
504
+
} else if value >= Meter.weight() {
533
505
return Number::with_basic_unit(value / Meter.weight(), Meter);
534
-
} else if value >= d!(10) {
535
-
// 1 cm
506
+
} else if value >= Centimeter.weight() {
536
507
return Number::with_basic_unit(value / Centimeter.weight(), Centimeter);
537
508
} else {
538
-
return Number::with_basic_unit(value, Millimeter);
509
+
return Number::with_basic_unit(value / Millimeter.weight(), Millimeter);
539
510
}
540
511
} else if primitive == Time.primitive() {
541
-
if value >= d!(31556952000000000) {
512
+
if value >= Year.weight() {
542
513
return Number::with_basic_unit(value / Year.weight(), Year);
543
-
} else if value >= d!(86400000000000) {
514
+
} else if value >= Day.weight() {
544
515
return Number::with_basic_unit(value / Day.weight(), Day);
545
-
} else if value >= d!(3600000000000) {
516
+
} else if value >= Hour.weight() {
546
517
return Number::with_basic_unit(value / Hour.weight(), Hour);
547
-
} else if value >= d!(60000000000) {
518
+
} else if value >= Minute.weight() {
548
519
return Number::with_basic_unit(value / Minute.weight(), Minute);
549
-
} else if value >= d!(1000000000) {
520
+
} else if value >= Second.weight() {
550
521
return Number::with_basic_unit(value / Second.weight(), Second);
551
-
} else if value >= d!(1000000) {
522
+
} else if value >= Millisecond.weight() {
552
523
return Number::with_basic_unit(value / Millisecond.weight(), Millisecond);
553
-
} else if value >= d!(1000) {
524
+
} else if value >= Microsecond.weight() {
554
525
return Number::with_basic_unit(value / Microsecond.weight(), Microsecond);
555
526
} else {
556
-
return Number::with_basic_unit(value, Nanosecond);
527
+
return Number::with_basic_unit(value / Nanosecond.weight(), Nanosecond);
557
528
}
558
529
} else if primitive == Area.primitive() {
559
-
if value >= d!(1000000000000) {
560
-
// 1 km2
530
+
if value >= SquareKilometer.weight() {
561
531
return Number::with_basic_unit(value / SquareKilometer.weight(), SquareKilometer);
562
-
} else if value >= d!(10000000000) {
563
-
// 1 hectare
532
+
} else if value >= Hectare.weight() {
564
533
return Number::with_basic_unit(value / Hectare.weight(), Hectare);
565
-
} else if value >= d!(1000000) {
566
-
// 1 m2
534
+
} else if value >= SquareMeter.weight() {
567
535
return Number::with_basic_unit(value / SquareMeter.weight(), SquareMeter);
568
-
} else if value >= d!(100) {
569
-
// 1 cm2
536
+
} else if value >= SquareCentimeter.weight() {
570
537
return Number::with_basic_unit(value / SquareCentimeter.weight(), SquareCentimeter);
571
538
} else {
572
-
return Number::with_basic_unit(value, SquareMillimeter);
539
+
return Number::with_basic_unit(value / SquareMillimeter.weight(), SquareMillimeter);
573
540
}
574
541
} else if primitive == Volume.primitive() {
575
-
if value >= d!(1000000000000000000) {
576
-
// 1 km3
542
+
if value >= CubicKilometer.weight() {
577
543
return Number::with_basic_unit(value / CubicKilometer.weight(), CubicKilometer);
578
-
} else if value >= d!(1000000000) {
579
-
// 1 m3
544
+
} else if value >= CubicMeter.weight() {
580
545
return Number::with_basic_unit(value / CubicMeter.weight(), CubicMeter);
581
-
} else if value >= d!(1000000) {
582
-
// 1 l
546
+
} else if value >= Liter.weight() {
583
547
return Number::with_basic_unit(value / Liter.weight(), Liter);
584
-
} else if value >= d!(1000) {
585
-
// 1 ml
548
+
} else if value >= Milliliter.weight() {
586
549
return Number::with_basic_unit(value / Milliliter.weight(), Milliliter);
587
550
} else {
588
-
return Number::with_basic_unit(value, CubicMillimeter);
551
+
return Number::with_basic_unit(value / CubicMillimeter.weight(), CubicMillimeter);
589
552
}
590
553
} else if primitive == Energy.primitive() {
591
-
if value >= d!(3600000000000000000) {
592
-
// 1 petawatthour
593
-
return Number::with_basic_unit(value / PetawattHour.weight(), PetawattHour);
594
-
} else if value >= d!(3600000000000000) {
595
-
// 1 terawatthour
596
-
return Number::with_basic_unit(value / TerawattHour.weight(), TerawattHour);
597
-
} else if value >= d!(3600000000000) {
598
-
// 1 gigawatthour
599
-
return Number::with_basic_unit(value / GigawattHour.weight(), GigawattHour);
600
-
} else if value >= d!(3600000000) {
601
-
// 1 megawatthour
602
-
return Number::with_basic_unit(value / MegawattHour.weight(), MegawattHour);
603
-
} else if value >= d!(3600000) {
604
-
// 1 kilowatthour
605
-
return Number::with_basic_unit(value / KilowattHour.weight(), KilowattHour);
606
-
} else if value >= d!(3600) {
607
-
// 1 watthour
608
-
return Number::with_basic_unit(value / WattHour.weight(), WattHour);
609
-
} else if value >= d!(1) {
610
-
// 1 joule
611
-
return Number::with_basic_unit(value, Joule);
554
+
let has_second = number.unit.iter().find(|unit| unit.0 == Second).is_some();
555
+
if has_second {
556
+
if value >= Terajoule.weight() {
557
+
return Number::with_basic_unit(value / Terajoule.weight(), Terajoule);
558
+
} else if value >= Gigajoule.weight() {
559
+
return Number::with_basic_unit(value / Gigajoule.weight(), Gigajoule);
560
+
} else if value >= Megajoule.weight() {
561
+
return Number::with_basic_unit(value / Megajoule.weight(), Megajoule);
562
+
} else if value >= Kilojoule.weight() {
563
+
return Number::with_basic_unit(value / Kilojoule.weight(), Kilojoule);
564
+
} else if value >= Joule.weight() {
565
+
return Number::with_basic_unit(value / Joule.weight(), Joule);
566
+
} else {
567
+
return Number::with_basic_unit(value / Millijoule.weight(), Millijoule);
568
+
}
612
569
} else {
613
-
return Number::with_basic_unit(value / Millijoule.weight(), Millijoule);
570
+
if value >= PetawattHour.weight() {
571
+
return Number::with_basic_unit(value / PetawattHour.weight(), PetawattHour);
572
+
} else if value >= TerawattHour.weight() {
573
+
return Number::with_basic_unit(value / TerawattHour.weight(), TerawattHour);
574
+
} else if value >= GigawattHour.weight() {
575
+
return Number::with_basic_unit(value / GigawattHour.weight(), GigawattHour);
576
+
} else if value >= MegawattHour.weight() {
577
+
return Number::with_basic_unit(value / MegawattHour.weight(), MegawattHour);
578
+
} else if value >= KilowattHour.weight() {
579
+
return Number::with_basic_unit(value / KilowattHour.weight(), KilowattHour);
580
+
} else if value >= WattHour.weight() {
581
+
return Number::with_basic_unit(value / WattHour.weight(), WattHour);
582
+
} else if value >= Joule.weight() {
583
+
return Number::with_basic_unit(value / Joule.weight(), Joule);
584
+
} else {
585
+
return Number::with_basic_unit(value / Millijoule.weight(), Millijoule);
586
+
}
614
587
}
615
588
} else if primitive == Power.primitive() {
616
-
if value >= d!(1000000000000000) {
617
-
// 1 petawatt
589
+
if value >= Petawatt.weight() {
618
590
return Number::with_basic_unit(value / Petawatt.weight(), Petawatt);
619
-
} else if value >= d!(1000000000000) {
620
-
// 1 terawatt
591
+
} else if value >= Terawatt.weight() {
621
592
return Number::with_basic_unit(value / Terawatt.weight(), Terawatt);
622
-
} else if value >= d!(1000000000) {
623
-
// 1 gigawatt
593
+
} else if value >= Gigawatt.weight() {
624
594
return Number::with_basic_unit(value / Gigawatt.weight(), Gigawatt);
625
-
} else if value >= d!(1000000) {
626
-
// megawatt
595
+
} else if value >= Megawatt.weight() {
627
596
return Number::with_basic_unit(value / Megawatt.weight(), Megawatt);
628
-
} else if value >= d!(1000) {
629
-
// 1 kilowatt
597
+
} else if value >= Kilowatt.weight() {
630
598
return Number::with_basic_unit(value / Kilowatt.weight(), Kilowatt);
631
-
} else if value >= d!(1) {
632
-
// 1 watt
633
-
return Number::with_basic_unit(value, Watt);
599
+
} else if value >= Watt.weight() {
600
+
return Number::with_basic_unit(value / Watt.weight(), Watt);
634
601
} else {
635
602
return Number::with_basic_unit(value / Milliwatt.weight(), Milliwatt);
636
603
}
637
604
} else if primitive == ElectricCurrent.primitive() {
638
-
if value >= d!(1000) {
639
-
// 1 kiloampere
605
+
if value >= Kiloampere.weight() {
640
606
return Number::with_basic_unit(value / Kiloampere.weight(), Kiloampere);
641
-
} else if value >= d!(1) {
642
-
// 1 ampere
643
-
return Number::with_basic_unit(value, Ampere);
607
+
} else if value >= Ampere.weight() {
608
+
return Number::with_basic_unit(value / Ampere.weight(), Ampere);
644
609
} else {
645
610
return Number::with_basic_unit(value / Milliampere.weight(), Milliampere);
646
611
}
647
612
} else if primitive == Resistance.primitive() {
648
-
if value >= d!(1000) {
649
-
// 1 kiloohm
613
+
if value >= Kiloohm.weight() {
650
614
return Number::with_basic_unit(value / Kiloohm.weight(), Kiloohm);
651
-
} else if value >= d!(1) {
652
-
// 1 ohm
653
-
return Number::with_basic_unit(value, Ohm);
615
+
} else if value >= Ohm.weight() {
616
+
return Number::with_basic_unit(value / Ohm.weight(), Ohm);
654
617
} else {
655
618
return Number::with_basic_unit(value / Milliohm.weight(), Milliohm);
656
619
}
657
620
} else if primitive == Voltage.primitive() {
658
-
if value >= d!(1000) {
659
-
// 1 kilovolt
621
+
if value >= Kilovolt.weight() {
660
622
return Number::with_basic_unit(value / Kilovolt.weight(), Kilovolt);
661
-
} else if value >= d!(1) {
662
-
// 1 volt
663
-
return Number::with_basic_unit(value, Volt);
623
+
} else if value >= Volt.weight() {
624
+
return Number::with_basic_unit(value / Volt.weight(), Volt);
664
625
} else {
665
626
return Number::with_basic_unit(value / Millivolt.weight(), Millivolt);
666
627
}
667
628
}
668
629
number
669
-
}
670
-
671
-
/// Convert a [`Number`] to an ideal [`Joule`] unit, if the number is a unit of [`Energy`].
672
-
pub fn to_ideal_joule_unit(number: Number) -> Number {
673
-
todo!();
674
-
// let value = number.value * number.unit.weight();
675
-
// if number.unit.category() == Energy {
676
-
// if value >= d!(1000000000000) { // 1 terajoule
677
-
// return Number::new(value/Terajoule.weight(), Terajoule)
678
-
// } else if value >= d!(1000000000) { // 1 gigajoule
679
-
// return Number::new(value/Gigajoule.weight(), Gigajoule)
680
-
// } else if value >= d!(1000000) { // 1 megajoule
681
-
// return Number::new(value/Megajoule.weight(), Megajoule)
682
-
// } else if value >= d!(1000) { // 1 kilojoule
683
-
// return Number::new(value/Kilojoule.weight(), Kilojoule)
684
-
// } else if value >= d!(1) { // 1 joule
685
-
// return Number::new(value/Joule.weight(), Joule)
686
-
// } else {
687
-
// return Number::new(value/Millijoule.weight(), Millijoule)
688
-
// }
689
-
// }
690
-
// number
691
630
}
692
631
693
632
/// Multiply two [`Number`]s