1 /*
2 * Copyright (C) 2018 Alberto Irurueta Carro (alberto@irurueta.com)
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 package com.irurueta.units;
18
19 import java.math.BigDecimal;
20
21 /**
22 * Contains an acceleration value and unit.
23 */
24 public class Acceleration extends Measurement<AccelerationUnit> {
25
26 /**
27 * Constructor with value and unit.
28 *
29 * @param value acceleration value.
30 * @param unit unit of acceleration.
31 * @throws IllegalArgumentException if either value or unit is null.
32 */
33 public Acceleration(final Number value, final AccelerationUnit unit) {
34 super(value, unit);
35 }
36
37 /**
38 * Constructor.
39 */
40 Acceleration() {
41 super();
42 }
43
44 /**
45 * Determines if two accelerations are equal up to a certain tolerance. If needed, this method attempts unit
46 * conversion to compare both objects.
47 *
48 * @param other another acceleration to compare.
49 * @param tolerance amount of tolerance to determine whether two acceleration instances are equal or not.
50 * @return true if provided acceleration is assumed to be equal to this instance, false otherwise.
51 */
52 @Override
53 public boolean equals(final Measurement<AccelerationUnit> other, final double tolerance) {
54 if (super.equals(other, tolerance)) {
55 return true;
56 }
57
58 // attempt conversion to common units
59 if (other == null) {
60 return false;
61 }
62
63 final var otherValue = AccelerationConverter.convert(other.getValue().doubleValue(),
64 other.getUnit(), getUnit());
65 return Math.abs(getValue().doubleValue() - otherValue) <= tolerance;
66 }
67
68 /**
69 * Adds two acceleration values and units and returns the result.
70 *
71 * @param value1 1st argument value.
72 * @param unit1 1st argument unit.
73 * @param value2 2nd argument value.
74 * @param unit2 2nd argument unit.
75 * @param resultUnit unit of result to be returned.
76 * @return result of addition.
77 */
78 public static double add(final double value1, final AccelerationUnit unit1,
79 final double value2, final AccelerationUnit unit2,
80 final AccelerationUnit resultUnit) {
81 final var v1 = AccelerationConverter.convert(value1, unit1, resultUnit);
82 final var v2 = AccelerationConverter.convert(value2, unit2, resultUnit);
83 return v1 + v2;
84 }
85
86 /**
87 * Adds two acceleration values and unit and returns the result.
88 *
89 * @param value1 1st argument value.
90 * @param unit1 1st argument unit.
91 * @param value2 2nd argument value.
92 * @param unit2 2nd argument unit.
93 * @param resultUnit unit of result to be returned.
94 * @return result of addition.
95 */
96 public static Number add(final Number value1, final AccelerationUnit unit1,
97 final Number value2, final AccelerationUnit unit2,
98 final AccelerationUnit resultUnit) {
99 return BigDecimal.valueOf(add(value1.doubleValue(), unit1, value2.doubleValue(), unit2, resultUnit));
100 }
101
102 /**
103 * Adds two acceleration instances and stores the result into provided instance.
104 *
105 * @param arg1 1st argument.
106 * @param arg2 2nd argument.
107 * @param result instance where result will be stored.
108 */
109 public static void add(final Acceleration arg1, final Acceleration arg2, final Acceleration result) {
110 result.setValue(add(arg1.getValue(), arg1.getUnit(), arg2.getValue(), arg2.getUnit(), result.getUnit()));
111 }
112
113 /**
114 * Adds two acceleration instances.
115 *
116 * @param arg1 1st argument.
117 * @param arg2 2nd argument.
118 * @param unit unit of returned acceleration.
119 * @return a new instance containing result.
120 */
121 public static Acceleration addAndReturnNew(
122 final Acceleration arg1, final Acceleration arg2, final AccelerationUnit unit) {
123 final var result = new Acceleration();
124 result.setUnit(unit);
125 add(arg1, arg2, result);
126 return result;
127 }
128
129 /**
130 * Adds provided acceleration value and unit and returns a new acceleration instance using provided unit.
131 *
132 * @param value value to be added.
133 * @param unit unit of value to be added.
134 * @param resultUnit unit of returned acceleration.
135 * @return a new acceleration containing result.
136 */
137 public Acceleration addAndReturnNew(
138 final double value, final AccelerationUnit unit, final AccelerationUnit resultUnit) {
139 final var result = new Acceleration();
140 result.setUnit(resultUnit);
141 result.setValue(add(getValue().doubleValue(), getUnit(), value, unit, resultUnit));
142 return result;
143 }
144
145 /**
146 * Adds provided acceleration value and unit and returns a new acceleration instance using provided unit.
147 *
148 * @param value value to be added.
149 * @param unit unit of value to be added.
150 * @param resultUnit unit of returned acceleration.
151 * @return a new acceleration containing result.
152 */
153 public Acceleration addAndReturnNew(
154 final Number value, final AccelerationUnit unit, final AccelerationUnit resultUnit) {
155 final var result = new Acceleration();
156 result.setUnit(resultUnit);
157 result.setValue(add(getValue(), getUnit(), value, unit, resultUnit));
158 return result;
159 }
160
161 /**
162 * Adds provided acceleration to current instance and returns a new acceleration.
163 *
164 * @param a acceleration to be added.
165 * @param unit unit of returned acceleration.
166 * @return a new acceleration containing result.
167 */
168 public Acceleration addAndReturnNew(final Acceleration a, final AccelerationUnit unit) {
169 return addAndReturnNew(this, a, unit);
170 }
171
172 /**
173 * Adds provided acceleration value and unit and updates current acceleration instance.
174 *
175 * @param value acceleration value to be added.
176 * @param unit unit of acceleration value.
177 */
178 public void add(final double value, final AccelerationUnit unit) {
179 setValue(add(getValue(), getUnit(), value, unit, getUnit()));
180 }
181
182 /**
183 * Adds provided acceleration value and unit and updates current acceleration instance.
184 *
185 * @param value acceleration value to be added.
186 * @param unit unit of acceleration value.
187 */
188 public void add(final Number value, final AccelerationUnit unit) {
189 setValue(add(getValue(), getUnit(), value, unit, getUnit()));
190 }
191
192 /**
193 * Adds provided acceleration and updates current acceleration.
194 *
195 * @param acceleration acceleration to be added.
196 */
197 public void add(final Acceleration acceleration) {
198 add(this, acceleration, this);
199 }
200
201 /**
202 * Adds provided acceleration and stores the result into provided acceleration.
203 *
204 * @param a acceleration to be added.
205 * @param result instance where result will be stored.
206 */
207 public void add(final Acceleration a, final Acceleration result) {
208 add(this, a, result);
209 }
210
211 /**
212 * Subtracts two acceleration values and units and returns the result.
213 *
214 * @param value1 1st argument value.
215 * @param unit1 1st argument unit.
216 * @param value2 2nd argument value.
217 * @param unit2 2nd argument unit.
218 * @param resultUnit unit of result to be returned.
219 * @return result of subtraction.
220 */
221 public static double subtract(final double value1, final AccelerationUnit unit1,
222 final double value2, final AccelerationUnit unit2,
223 final AccelerationUnit resultUnit) {
224 final var v1 = AccelerationConverter.convert(value1, unit1, resultUnit);
225 final var v2 = AccelerationConverter.convert(value2, unit2, resultUnit);
226 return v1 - v2;
227 }
228
229 /**
230 * Subtracts two acceleration values and units and returns the result.
231 *
232 * @param value1 1st argument value.
233 * @param unit1 1st argument unit.
234 * @param value2 2nd argument value.
235 * @param unit2 2nd argument unit.
236 * @param resultUnit unit of result to be returned.
237 * @return result of subtraction.
238 */
239 public static Number subtract(final Number value1, final AccelerationUnit unit1,
240 final Number value2, final AccelerationUnit unit2,
241 final AccelerationUnit resultUnit) {
242 return BigDecimal.valueOf(subtract(value1.doubleValue(), unit1,
243 value2.doubleValue(), unit2, resultUnit));
244 }
245
246 /**
247 * Subtracts two acceleration instances and stores the result into provided instance.
248 *
249 * @param arg1 1st argument.
250 * @param arg2 2nd argument.
251 * @param result instance where result will be stored.
252 */
253 public static void subtract(final Acceleration arg1, final Acceleration arg2,
254 final Acceleration result) {
255 result.setValue(subtract(arg1.getValue(), arg1.getUnit(), arg2.getValue(), arg2.getUnit(), result.getUnit()));
256 }
257
258 /**
259 * Subtracts two acceleration instances.
260 *
261 * @param arg1 1st argument.
262 * @param arg2 2nd argument.
263 * @param unit unit of returned acceleration.
264 * @return a new instance containing result.
265 */
266 public static Acceleration subtractAndReturnNew(
267 final Acceleration arg1, final Acceleration arg2, final AccelerationUnit unit) {
268 final var result = new Acceleration();
269 result.setUnit(unit);
270 subtract(arg1, arg2, result);
271 return result;
272 }
273
274 /**
275 * Subtracts provided acceleration value and unit and returns a new acceleration instance using provided unit.
276 *
277 * @param value value to be subtracted.
278 * @param unit unit of value to be subtracted.
279 * @param resultUnit unit of returned acceleration.
280 * @return a new acceleration containing result.
281 */
282 public Acceleration subtractAndReturnNew(
283 final double value, final AccelerationUnit unit, final AccelerationUnit resultUnit) {
284 final var result = new Acceleration();
285 result.setUnit(resultUnit);
286 result.setValue(subtract(getValue().doubleValue(), getUnit(), value, unit, resultUnit));
287 return result;
288 }
289
290 /**
291 * Subtracts provided acceleration value and unit and returns a new acceleration instance using provided unit.
292 *
293 * @param value value to be subtracted.
294 * @param unit unit of value to be subtracted.
295 * @param resultUnit unit of returned acceleration.
296 * @return a new acceleration containing result.
297 */
298 public Acceleration subtractAndReturnNew(
299 final Number value, final AccelerationUnit unit, final AccelerationUnit resultUnit) {
300 final var result = new Acceleration();
301 result.setUnit(resultUnit);
302 result.setValue(subtract(getValue(), getUnit(), value, unit, resultUnit));
303 return result;
304 }
305
306 /**
307 * Subtracts provided acceleration to current instance and returns a new acceleration instance.
308 *
309 * @param a acceleration to be subtracted.
310 * @param unit unit of returned acceleration.
311 * @return a new acceleration containing result.
312 */
313 public Acceleration subtractAndReturnNew(final Acceleration a, final AccelerationUnit unit) {
314 return subtractAndReturnNew(this, a, unit);
315 }
316
317 /**
318 * Subtracts provided acceleration value and unit and updates current acceleration instance.
319 *
320 * @param value acceleration value to be subtracted.
321 * @param unit unit of acceleration value.
322 */
323 public void subtract(final double value, final AccelerationUnit unit) {
324 setValue(subtract(getValue(), getUnit(), value, unit, getUnit()));
325 }
326
327 /**
328 * Subtracts provided acceleration value and unit and updates current acceleration instance.
329 *
330 * @param value acceleration value to be subtracted.
331 * @param unit unit of acceleration value.
332 */
333 public void subtract(final Number value, final AccelerationUnit unit) {
334 setValue(subtract(getValue(), getUnit(), value, unit, getUnit()));
335 }
336
337 /**
338 * Subtracts provided acceleration and updates current acceleration.
339 *
340 * @param acceleration acceleration to be subtracted.
341 */
342 public void subtract(final Acceleration acceleration) {
343 subtract(this, acceleration, this);
344 }
345
346 /**
347 * Subtracts provided acceleration and stores the result into provided acceleration.
348 *
349 * @param a acceleration to be subtracted.
350 * @param result instance where result will be stored.
351 */
352 public void subtract(final Acceleration a, final Acceleration result) {
353 subtract(this, a, result);
354 }
355 }