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