001 /*
002 * Java Genetic Algorithm Library (jenetics-5.1.0).
003 * Copyright (c) 2007-2019 Franz Wilhelmstötter
004 *
005 * Licensed under the Apache License, Version 2.0 (the "License");
006 * you may not use this file except in compliance with the License.
007 * You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 *
017 * Author:
018 * Franz Wilhelmstötter (franz.wilhelmstoetter@gmail.com)
019 */
020 package io.jenetics.ext.moea;
021
022 import static java.util.Objects.requireNonNull;
023
024 import java.io.Serializable;
025 import java.util.Arrays;
026 import java.util.Comparator;
027
028 /**
029 * {@link Vec} implementations for basic array types.
030 *
031 * @author <a href="mailto:franz.wilhelmstoetter@gmail.com">Franz Wilhelmstötter</a>
032 * @version 4.1
033 * @since 4.1
034 */
035 final class Vecs {
036
037 private Vecs() {
038 }
039
040 private static void checkVecLength(final int length) {
041 if (length <= 0) {
042 throw new IllegalArgumentException("Array length must greater zero.");
043 }
044 }
045
046 static final class ObjectVec<T> implements Vec<T[]> {
047 private final T[] _data;
048 private final Comparator<? super T> _comparator;
049 private final ElementDistance<T[]> _distance;
050
051 ObjectVec(
052 final T[] data,
053 final Comparator<? super T> comparator,
054 final ElementDistance<T[]> distance
055 ) {
056 checkVecLength(data.length);
057 _data = data;
058 _comparator = requireNonNull(comparator);
059 _distance = requireNonNull(distance);
060 }
061
062 @Override
063 public T[] data() {
064 return _data;
065 }
066
067 @Override
068 public int length() {
069 return _data.length;
070 }
071
072 @Override
073 public ElementComparator<T[]> comparator() {
074 return (u, v, i) -> _comparator.compare(u[i], v[i]);
075 }
076
077 @Override
078 public ElementDistance<T[]> distance() {
079 return _distance;
080 }
081
082 @Override
083 public Comparator<T[]> dominance() {
084 return (u, v) -> Vec.dominance(u, v, _comparator);
085 }
086
087 @Override
088 public int hashCode() {
089 return Arrays.hashCode(_data);
090 }
091
092 @Override
093 public boolean equals(final Object obj) {
094 return obj == this ||
095 obj instanceof ObjectVec &&
096 Arrays.equals(((ObjectVec)obj)._data, _data);
097 }
098
099 @Override
100 public String toString() {
101 return Arrays.toString(_data);
102 }
103
104 }
105
106 static final class IntVec implements Vec<int[]>, Serializable {
107 private static final long serialVersionUID = 1L;
108
109 private final int[] _data;
110
111 IntVec(final int[] data) {
112 checkVecLength(data.length);
113 _data = data;
114 }
115
116 @Override
117 public int[] data() {
118 return _data;
119 }
120
121 @Override
122 public int length() {
123 return _data.length;
124 }
125
126 @Override
127 public ElementComparator<int[]> comparator() {
128 return (u, v, i) -> Integer.compare(u[i], v[i]);
129 }
130
131 @Override
132 public ElementDistance<int[]> distance() {
133 return (u, v, i) -> u[i] - v[i];
134 }
135
136 @Override
137 public Comparator<int[]> dominance() {
138 return Vec::dominance;
139 }
140
141 @Override
142 public int hashCode() {
143 return Arrays.hashCode(_data);
144 }
145
146 @Override
147 public boolean equals(final Object obj) {
148 return obj == this ||
149 obj instanceof IntVec &&
150 Arrays.equals(((IntVec)obj)._data, _data);
151 }
152
153 @Override
154 public String toString() {
155 return Arrays.toString(_data);
156 }
157
158 }
159
160 static final class LongVec implements Vec<long[]>, Serializable {
161 private static final long serialVersionUID = 1L;
162
163 private final long[] _data;
164
165 LongVec(final long[] data) {
166 checkVecLength(data.length);
167 _data = data;
168 }
169
170 @Override
171 public long[] data() {
172 return _data;
173 }
174
175 @Override
176 public int length() {
177 return _data.length;
178 }
179
180 @Override
181 public ElementComparator<long[]> comparator() {
182 return (u, v, i) -> Long.compare(u[i], v[i]);
183 }
184
185 @Override
186 public ElementDistance<long[]> distance() {
187 return (u, v, i) -> u[i] - v[i];
188 }
189
190 @Override
191 public Comparator<long[]> dominance() {
192 return Vec::dominance;
193 }
194
195 @Override
196 public int hashCode() {
197 return Arrays.hashCode(_data);
198 }
199
200 @Override
201 public boolean equals(final Object obj) {
202 return obj == this ||
203 obj instanceof LongVec &&
204 Arrays.equals(((LongVec)obj)._data, _data);
205 }
206
207 @Override
208 public String toString() {
209 return Arrays.toString(_data);
210 }
211
212 }
213
214 static final class DoubleVec implements Vec<double[]>, Serializable {
215 private static final long serialVersionUID = 1L;
216
217 private final double[] _data;
218
219 DoubleVec(final double[] data) {
220 checkVecLength(data.length);
221 _data = data;
222 }
223
224 @Override
225 public double[] data() {
226 return _data;
227 }
228
229 @Override
230 public int length() {
231 return _data.length;
232 }
233
234 @Override
235 public ElementComparator<double[]> comparator() {
236 return (u, v, i) -> Double.compare(u[i], v[i]);
237 }
238
239 @Override
240 public ElementDistance<double[]> distance() {
241 return (u, v, i) -> u[i] - v[i];
242 }
243
244 @Override
245 public Comparator<double[]> dominance() {
246 return Vec::dominance;
247 }
248
249 @Override
250 public int hashCode() {
251 return Arrays.hashCode(_data);
252 }
253
254 @Override
255 public boolean equals(final Object obj) {
256 return obj == this ||
257 obj instanceof DoubleVec &&
258 Arrays.equals(((DoubleVec)obj)._data, _data);
259 }
260
261 @Override
262 public String toString() {
263 return Arrays.toString(_data);
264 }
265
266 }
267
268
269 }
|