libStatGen Software
1
IntArray.h
1
/*
2
* Copyright (C) 2010 Regents of the University of Michigan
3
*
4
* This program is free software: you can redistribute it and/or modify
5
* it under the terms of the GNU General Public License as published by
6
* the Free Software Foundation, either version 3 of the License, or
7
* (at your option) any later version.
8
*
9
* This program is distributed in the hope that it will be useful,
10
* but WITHOUT ANY WARRANTY; without even the implied warranty of
11
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12
* GNU General Public License for more details.
13
*
14
* You should have received a copy of the GNU General Public License
15
* along with this program. If not, see <http://www.gnu.org/licenses/>.
16
*/
17
18
#ifndef __INTARRAY_H__
19
#define __INTARRAY_H__
20
21
#include <stdio.h>
22
23
class
IntArray
24
{
25
private
:
26
int
* items;
27
int
size, count;
28
29
void
Grow(
int
new_size);
30
static
int
Compare(
int
* a,
int
* b);
31
32
public
:
33
static
int
alloc;
34
35
IntArray
(
int
start_size = 0);
36
IntArray
(
const
IntArray
& source);
37
~
IntArray
();
38
39
IntArray
& operator = (
const
IntArray
& rhs);
40
41
int
& operator [](
int
index)
42
{
43
return
items[index];
44
}
45
int
operator [](
int
index)
const
46
{
47
return
items[index];
48
}
49
50
// Suggested by Anthony Berno, 12/28/06, to avoid "ambiguities" that
51
// Visual Studio encountered when handling implicit conversions ...
52
int
& operator [](
char
index)
53
{
54
return
items[int(index)];
55
}
56
int
operator [](
char
index)
const
57
{
58
return
items[int(index)];
59
}
60
// ... who knows whether Visual Studio makes C++ annoying to encourage C#?
61
62
int
& operator [](
double
fraction)
63
{
64
return
items[(int)(count * fraction)];
65
}
66
int
operator [](
double
fraction)
const
67
{
68
return
items[(int)(count * fraction)];
69
}
70
71
int
Append(
int
value);
72
int
Append(
const
IntArray
& rhs);
73
74
void
Push(
int
value)
75
{
76
Append(value);
77
}
78
int
Pop()
79
{
80
return
items[--count];
81
}
82
int
Peek()
const
83
{
84
return
items[count - 1];
85
}
86
int
&Last()
const
87
{
88
return
items[count - 1];
89
}
90
91
void
PushIfNew(
int
value);
// used for maintaining list without duplicates
92
93
int
Delete(
int
index);
94
void
InsertAt(
int
index,
int
value);
95
96
int
Find(
int
value)
const
;
97
int
FastFind(
int
value)
const
98
{
99
return
BinarySearch(value);
100
}
101
int
BinarySearch(
int
value)
const
;
102
void
Sort();
103
void
Sort(
IntArray
& freeRider);
// Sorts two arrays simultaneously
104
105
void
Zero();
106
void
Set(
int
value);
107
void
SetSequence(
int
start = 0,
int
increment = 1);
108
109
int
Length()
const
110
{
111
return
count;
112
}
113
void
Dimension(
int
new_count)
114
{
115
Grow(new_count);
116
count = new_count;
117
}
118
void
Clear()
119
{
120
count = 0;
121
}
122
123
int
Sum()
const
124
{
125
return
Sum(0, count - 1);
126
}
127
int
Sum(
int
start)
const
128
{
129
return
Sum(start, count - 1);
130
}
131
int
Sum(
int
start,
int
end)
const
;
132
133
double
dSum()
const
134
{
135
return
dSum(0, count - 1);
136
}
137
double
dSum(
int
start)
const
138
{
139
return
dSum(start, count - 1);
140
}
141
double
dSum(
int
start,
int
end)
const
;
142
143
int
SumProduct(
const
IntArray
& weight)
const
;
144
double
dSumProduct(
const
IntArray
& weight)
const
;
145
146
int
Max()
const
147
{
148
return
Max(0, count - 1);
149
}
150
int
Max(
int
start)
const
151
{
152
return
Max(start, count - 1);
153
}
154
int
Max(
int
start,
int
end)
const
;
155
156
int
Min()
const
157
{
158
return
Min(0, count - 1);
159
}
160
int
Min(
int
start)
const
161
{
162
return
Min(start, count - 1);
163
}
164
int
Min(
int
start,
int
end)
const
;
165
166
int
Count()
const
167
{
168
return
count;
169
}
170
int
CountIfGreater(
int
treshold)
const
;
171
int
CountIfGreaterOrEqual(
int
treshold)
const
;
172
173
void
Swap(
int
i,
int
j)
174
{
175
int
tmp = items[i];
176
items[i] = items[j];
177
items[j] = tmp;
178
}
179
180
void
Reverse();
181
182
operator
int
*()
183
{
184
return
items;
185
}
186
187
void
Add(
int
term);
188
void
Subtract(
int
term)
189
{
190
Add(-term);
191
}
192
void
Multiply(
int
factor);
193
void
Divide(
int
denominator);
194
195
void
Add(
const
IntArray
& rhs);
196
197
IntArray
& operator += (
int
rhs)
198
{
199
Add(rhs);
200
return
*
this
;
201
}
202
203
IntArray
& operator += (
const
IntArray
& rhs)
204
{
205
Add(rhs);
206
return
*
this
;
207
}
208
209
IntArray
& operator *= (
int
rhs)
210
{
211
Multiply(rhs);
212
return
*
this
;
213
}
214
215
IntArray
& operator -= (
int
rhs)
216
{
217
Add(-rhs);
218
return
*
this
;
219
}
220
221
IntArray
& operator /= (
int
rhs)
222
{
223
Divide(rhs);
224
return
*
this
;
225
}
226
227
int
InnerProduct(
IntArray
& v);
228
229
bool
operator == (
const
IntArray
& rhs)
const
;
230
bool
operator != (
const
IntArray
& rhs)
const
;
231
232
bool
isAscending();
233
bool
isDescending();
234
235
void
Stack(
const
IntArray
& rhs);
236
237
void
Swap(
IntArray
& rhs);
238
239
void
Print()
240
{
241
Print(stdout);
242
}
243
void
Print(
const
char
* label)
244
{
245
Print(stdout, label);
246
}
247
void
Print(FILE * output);
248
void
Print(FILE * output,
const
char
* label);
249
250
int
Product();
251
double
DoubleProduct();
252
253
int
Hash(
int
initval = 0);
254
};
255
256
#endif
257
258
IntArray
Definition:
IntArray.h:23
general
IntArray.h
Generated by
1.8.17