void Vector<T>::push_back(const T e) {
if (cap_array == 0 && size_array == 0) {
increase_capacity(20);
}
if (cap_array == 0 && size_array != 0) {
increase_capacity(size_array*2);
}
if (size_array >= cap_array) {
increase_capacity(2 * cap_array);
}
array[size_array] = e;
++size_array;
}
static void test_increase_capacity(void)
{
/* Initialize a new list to [4, 7, 3, -2, 9] */
intlist_t list = intlist_construct(5);
list = intlist_append(list, 4);
list = intlist_append(list, 7);
list = intlist_append(list, 3);
list = intlist_append(list, -2);
list = intlist_append(list, 9);
int *old_array = list.elems;
/* Increase the list's capacity from 5 to 10. */
list = increase_capacity(list, 10);
sput_fail_unless(list.capacity == 10,
"list = intlist_construct(10);\n"
"Initialized list to [4 7 3 -2 9]\n"
"list = increase_capacity(list, 10)\n"
"Verifying list capacity increased from 5 to 10");
sput_fail_unless(list.elems != old_array,
"Verifying that a new array was allocated");
int expected[] = {4, 7, 3, -2, 9};
sput_fail_unless(compare_arrays(list.elems, expected, 5),
"Verifying that list still contains [4 7 3 -2 9]");
intlist_destroy(list);
}
void ARingTower::subtract_in_place(int level, poly &f, const poly g) const
{
if (g == 0) return;
if (f == 0)
{
f = copy(level, g);
negate_in_place(level, f);
return;
}
int fdeg = f->deg;
int gdeg = g->deg;
increase_capacity(g->deg, f);
if (level == 0)
for (int i = 0; i <= gdeg; i++)
mBaseRing.subtract(f->coeffs[i], f->coeffs[i], g->coeffs[i]);
else
for (int i = 0; i <= gdeg; i++)
subtract_in_place(level - 1, f->polys[i], g->polys[i]);
if (gdeg > fdeg)
f->deg = gdeg;
else if (gdeg == fdeg)
reset_degree(f);
}
void vector_push_back(vector *v, void *value)
{
assert(v != NULL);
if (v->size == v->capacity)
increase_capacity(v);
v->items[v->size++] = value;
}
void DArray<T>::specialDouble()
{
int new_size = n*2;
if(new_size > capacity)
increase_capacity(2 * capacity);
std::memcpy(&arr[n], &arr[0], sizeof(T)*n);
n = new_size;
}
static int ccommand_add_arg_private(struct ccommand *cmd, const char *arg)
{
if (cmd->capacity <= cmd->nargs && increase_capacity(cmd) < 0) {
return -1;
}
int idx = cmd->nargs++;
cmd->args[idx] = xstrdup(arg);
if (arg && !cmd->args[idx])
return -1;
return 0;
}
void vector_insert(vector *v, size_t pos, void *value)
{
assert(v != NULL);
assert(pos < v->size);
if (v->size == v->capacity)
increase_capacity(v);
memmove(v->items + pos + 1, v->items + pos, (v->size - pos) * sizeof *v->items);
v->items[pos] = value;
v->size++;
}
R_API int r_queue_enqueue (RQueue *q, void *el) {
if (is_full(q)) {
int res = increase_capacity (q);
if (!res)
return R_FALSE;
}
q->rear = (q->rear + 1) % q->capacity;
q->elems[q->rear] = el;
q->size++;
return R_TRUE;
}
extern symbol * add_s_to_b(symbol * p, const char * s) {
int n = strlen(s);
int k;
if (p == 0) p = create_b(n);
k = SIZE(p);
{
int x = k + n - CAPACITY(p);
if (x > 0) p = increase_capacity(p, x);
}
{
int i;
for (i = 0; i < n; i++) p[i + k] = s[i];
}
SIZE(p) += n;
return p;
}
extern symbol * add_to_b(symbol * p, int n, symbol * q) {
int x = SIZE(p) + n - CAPACITY(p);
if (x > 0) p = increase_capacity(p, x);
memmove(p + SIZE(p), q, n * sizeof(symbol)); SIZE(p) += n; return p;
}
extern symbol * move_to_b(symbol * p, int n, const symbol * q) {
int x = n - CAPACITY(p);
if (x > 0) p = increase_capacity(p, x);
memmove(p, q, n * sizeof(symbol)); SIZE(p) = n; return p;
}
void DArray<T>::push_back(T const& x) {
if (n >= capacity) increase_capacity (2 * capacity);
arr[n] = x;
n++;
}
