1 /*
2 * Licensed to the Hipparchus project under one or more
3 * contributor license agreements. See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The Hipparchus project licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
8 *
9 * https://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17 package org.hipparchus.analysis.differentiation;
18
19 import java.io.Serializable;
20
21 import org.hipparchus.Field;
22
23 /** Field for {@link UnivariateDerivative2} instances.
24 * <p>
25 * This class is a singleton.
26 * </p>
27 * @since 1.7
28 */
29 public class UnivariateDerivative2Field implements Field<UnivariateDerivative2>, Serializable {
30
31 /** Serializable version identifier. */
32 private static final long serialVersionUID = 20200520L;
33
34 /** Zero constant. */
35 private final UnivariateDerivative2 zero;
36
37 /** One constant. */
38 private final UnivariateDerivative2 one;
39
40 /** Associated factory for conversions to {@link DerivativeStructure}. */
41 private final DSFactory factory;
42
43 /** Private constructor for the singleton.
44 */
45 private UnivariateDerivative2Field() {
46 zero = new UnivariateDerivative2(0.0, 0.0, 0.0);
47 one = new UnivariateDerivative2(1.0, 0.0, 0.0);
48 factory = new DSFactory(1, 2);
49 }
50
51 /** Get the unique instance.
52 * @return the unique instance
53 */
54 public static UnivariateDerivative2Field getInstance() {
55 return LazyHolder.INSTANCE;
56 }
57
58 /** {@inheritDoc} */
59 @Override
60 public UnivariateDerivative2 getOne() {
61 return one;
62 }
63
64 /** {@inheritDoc} */
65 @Override
66 public UnivariateDerivative2 getZero() {
67 return zero;
68 }
69
70 /** Get the factory for converting to {@link DerivativeStructure}.
71 * <p>
72 * This factory is used only for conversions. {@code UnivariateDerivative2} by
73 * itself does not rely at all on {@link DSFactory}, {@link DSCompiler}
74 * or {@link DerivativeStructure} for its computation. For this reason,
75 * the factory here is hidden and this method is package private, so
76 * only {@link UnivariateDerivative2#toDerivativeStructure()} can call it on an
77 * existing {@link UnivariateDerivative2} instance
78 * </p>
79 * @return factory for conversions
80 */
81 DSFactory getConversionFactory() {
82 return factory;
83 }
84
85 /** {@inheritDoc} */
86 @Override
87 public Class<UnivariateDerivative2> getRuntimeClass() {
88 return UnivariateDerivative2.class;
89 }
90
91 /** {@inheritDoc} */
92 @Override
93 public boolean equals(final Object other) {
94 return this == other;
95 }
96
97 /** {@inheritDoc} */
98 @Override
99 public int hashCode() {
100 return 0x71f43303;
101 }
102
103 // CHECKSTYLE: stop HideUtilityClassConstructor
104 /** Holder for the instance.
105 * <p>We use here the Initialization On Demand Holder Idiom.</p>
106 */
107 private static class LazyHolder {
108 /** Cached field instance. */
109 private static final UnivariateDerivative2Field INSTANCE = new UnivariateDerivative2Field();
110 }
111 // CHECKSTYLE: resume HideUtilityClassConstructor
112
113 /** Handle deserialization of the singleton.
114 * @return the singleton instance
115 */
116 private Object readResolve() {
117 // return the singleton instance
118 return LazyHolder.INSTANCE;
119 }
120
121 }