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
|
/*
* Copyright (C) 2014-2021 Brian L. Browning
*
* This file is part of Beagle
*
* Beagle is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Beagle 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package ints;
/**
* <p>Class {@code IndexArray} stores an array whose entries
* are elements of a bounded set of non-negative integers along with an upper
* bound. Both the stored array and upper bound are specified at the time of
* object construction. It is the client code that constructs a
* {@code IndexArray} object's responsibility to ensure that the bound
* specified at construction is correct. The contract for this class
* is undefined if the bound is specified at object construction is incorrect.
* It is recommended that the bound be the minimum integer that is greater
* than all elements in the stored array, but not is not a requirement.
* </p>
* <p>Instances of class {@code IndexArray} are immutable.
* </p>
*
* @author Brian L. Browning {@code <browning@uw.edu>}
*/
public class IndexArray implements IntArray {
private final IntArray intArray;
private final int valueSize;
/**
* Constructs a new {@code IndexArray} instance from the specified
* data. The contract for this constructor and class is unspecified if
* the sequence indices are not a subset of
* {@code 0, 1, ..., (valueSize - 1)}.
*
* @param intArray an array with non-negative values
* @param valueSize a value that is greater than all elements
* of the specified array
* @throws NullPointerException if {@code IndexArray == null}
*/
public IndexArray(int[] intArray, int valueSize) {
if (intArray==null) {
throw new NullPointerException(IntArray.class.toString());
}
this.intArray = IntArray.packedCreate(intArray, valueSize);
this.valueSize = valueSize;
}
/**
* Constructs a new {@code IndexArray} instance from the specified
* data. The contract for this constructor and class is unspecified if
* the sequence indices are not a subset of
* {@code 0, 1, ..., (valueSize - 1)}.
*
* @param intArray an array with non-negative values
* @param valueSize a value that is greater than all elements
* of the specified array
* @throws NullPointerException if {@code IndexArray == null}
*/
public IndexArray(IntArray intArray, int valueSize) {
if (intArray==null) {
throw new NullPointerException(IntArray.class.toString());
}
this.intArray = intArray;
this.valueSize = valueSize;
}
@Override
public int get(int index) {
return intArray.get(index);
}
@Override
public int size() {
return intArray.size();
}
/**
* Returns the value size that was specified at construction.
* @return the value size that was specified at construction
*/
public int valueSize() {
return valueSize;
}
/**
* Returns the wrapped {@code IntArray} object.
* @return the wrapped {@code IntArray} object
*/
public IntArray intArray() {
return intArray;
}
/**
* Returns the minimum integer that is greater than all elements in the
* specified array of non-negative values.
* @param ia an array of non-negative values
* @return the minimum integer that is greater than all elements in the
* specified array of non-negative values
* @throws IllegalArgumentException if any element of the specified array is
* negative
*/
public static int valueSize(int[] ia) {
int max = -1;
for (int i : ia) {
if (i<0) {
throw new IllegalArgumentException(String.valueOf(i));
}
if (i > max) {
max = i;
}
}
return (max + 1);
}
/**
* Returns the minimum integer that is greater than all elements in the
* specified list of non-negative values.
* @param ia an array of non-negative values
* @return the minimum integer that is greater than all elements in the
* specified array of non-negative values
* @throws IllegalArgumentException if any element of the specified array
* is negative
*/
public static int valueSize(IntArray ia) {
int max = -1;
for (int j=0, n=ia.size(); j<n; ++j) {
int i = ia.get(j);
if (i<0) {
throw new IllegalArgumentException(String.valueOf(i));
}
if (i > max) {
max = i;
}
}
return (max + 1);
}
}
|
