1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
/**
* Copyright (C) 2019 Adrien Hopkins
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package org.unitConverter.unit;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.function.DoubleUnaryOperator;
import org.unitConverter.math.ObjectProduct;
/**
* A unit that is composed of base units.
*
* @author Adrien Hopkins
* @since 2019-10-16
*/
public abstract class Unit {
/**
* Returns a unit from its base and the functions it uses to convert to and from its base.
*
* <p>
* For example, to get a unit representing the degree Celsius, the following code can be used:
*
* {@code Unit.fromConversionFunctions(SI.KELVIN, tempK -> tempK - 273.15, tempC -> tempC + 273.15);}
* </p>
*
* @param base
* unit's base
* @param converterFrom
* function that accepts a value expressed in the unit's base and returns that value expressed in this
* unit.
* @param converterTo
* function that accepts a value expressed in the unit and returns that value expressed in the unit's
* base.
* @return a unit that uses the provided functions to convert.
* @since 2019-05-22
* @throws NullPointerException
* if any argument is null
*/
public static Unit fromConversionFunctions(final ObjectProduct<BaseUnit> base,
final DoubleUnaryOperator converterFrom, final DoubleUnaryOperator converterTo) {
return FunctionalUnit.valueOf(base, converterFrom, converterTo);
}
/**
* The combination of units that this unit is based on.
*
* @since 2019-10-16
*/
private final ObjectProduct<BaseUnit> unitBase;
/**
* Cache storing the result of getDimension()
*
* @since 2019-10-16
*/
private transient ObjectProduct<BaseDimension> dimension = null;
/**
* A constructor that constructs {@code BaseUnit} instances.
*
* @since 2019-10-16
*/
Unit() {
if (this instanceof BaseUnit) {
this.unitBase = ObjectProduct.oneOf((BaseUnit) this);
} else
throw new AssertionError();
}
/**
* Creates the {@code AbstractUnit}.
*
* @param unitBase
* @since 2019-10-16
* @throws NullPointerException
* if unitBase is null
*/
protected Unit(final ObjectProduct<BaseUnit> unitBase) {
this.unitBase = Objects.requireNonNull(unitBase, "unitBase must not be null.");
}
/**
* Checks if a value expressed in this unit can be converted to a value expressed in {@code other}
*
* @param other
* unit to test with
* @return true if the units are compatible
* @since 2019-01-13
* @since v0.1.0
* @throws NullPointerException
* if other is null
*/
public final boolean canConvertTo(final Unit other) {
Objects.requireNonNull(other, "other must not be null.");
return Objects.equals(this.getBase(), other.getBase());
}
/**
* Converts from a value expressed in this unit's base unit to a value expressed in this unit.
* <p>
* This must be the inverse of {@code convertToBase}, so {@code convertFromBase(convertToBase(value))} must be equal
* to {@code value} for any value, ignoring precision loss by roundoff error.
* </p>
* <p>
* If this unit <i>is</i> a base unit, this method should return {@code value}.
* </p>
*
* @param value
* value expressed in <b>base</b> unit
* @return value expressed in <b>this</b> unit
* @since 2018-12-22
* @since v0.1.0
*/
protected abstract double convertFromBase(double value);
/**
* Converts a value expressed in this unit to a value expressed in {@code other}.
*
* @param other
* unit to convert to
* @param value
* value to convert
* @return converted value
* @since 2019-05-22
* @throws IllegalArgumentException
* if {@code other} is incompatible for conversion with this unit (as tested by
* {@link IUnit#canConvertTo}).
* @throws NullPointerException
* if other is null
*/
public final double convertTo(final Unit other, final double value) {
Objects.requireNonNull(other, "other must not be null.");
if (this.canConvertTo(other))
return other.convertFromBase(this.convertToBase(value));
else
throw new IllegalArgumentException(String.format("Cannot convert from %s to %s.", this, other));
}
/**
* Converts from a value expressed in this unit to a value expressed in this unit's base unit.
* <p>
* This must be the inverse of {@code convertFromBase}, so {@code convertToBase(convertFromBase(value))} must be
* equal to {@code value} for any value, ignoring precision loss by roundoff error.
* </p>
* <p>
* If this unit <i>is</i> a base unit, this method should return {@code value}.
* </p>
*
* @param value
* value expressed in <b>this</b> unit
* @return value expressed in <b>base</b> unit
* @since 2018-12-22
* @since v0.1.0
*/
protected abstract double convertToBase(double value);
/**
* @return combination of units that this unit is based on
* @since 2018-12-22
* @since v0.1.0
*/
public final ObjectProduct<BaseUnit> getBase() {
return this.unitBase;
}
/**
* @return dimension measured by this unit
* @since 2018-12-22
* @since v0.1.0
*/
public final ObjectProduct<BaseDimension> getDimension() {
if (this.dimension == null) {
final Map<BaseUnit, Integer> mapping = this.unitBase.exponentMap();
final Map<BaseDimension, Integer> dimensionMap = new HashMap<>();
for (final BaseUnit key : mapping.keySet()) {
dimensionMap.put(key.getBaseDimension(), mapping.get(key));
}
this.dimension = ObjectProduct.fromExponentMapping(dimensionMap);
}
return this.dimension;
}
@Override
public String toString() {
return "Unit derived from base " + this.getBase().toString();
}
}
|
