static int dct_quantize_altivec(MpegEncContext* s,
DCTELEM* data, int n,
int qscale, int* overflow)
{
int lastNonZero;
vector float row0, row1, row2, row3, row4, row5, row6, row7;
vector float alt0, alt1, alt2, alt3, alt4, alt5, alt6, alt7;
const vector float zero = (const vector float)FOUROF(0.);
// used after quantize step
int oldBaseValue = 0;
// Load the data into the row/alt vectors
{
vector signed short data0, data1, data2, data3, data4, data5, data6, data7;
data0 = vec_ld(0, data);
data1 = vec_ld(16, data);
data2 = vec_ld(32, data);
data3 = vec_ld(48, data);
data4 = vec_ld(64, data);
data5 = vec_ld(80, data);
data6 = vec_ld(96, data);
data7 = vec_ld(112, data);
// Transpose the data before we start
TRANSPOSE8(data0, data1, data2, data3, data4, data5, data6, data7);
// load the data into floating point vectors. We load
// the high half of each row into the main row vectors
// and the low half into the alt vectors.
row0 = vec_ctf(vec_unpackh(data0), 0);
alt0 = vec_ctf(vec_unpackl(data0), 0);
row1 = vec_ctf(vec_unpackh(data1), 0);
alt1 = vec_ctf(vec_unpackl(data1), 0);
row2 = vec_ctf(vec_unpackh(data2), 0);
alt2 = vec_ctf(vec_unpackl(data2), 0);
row3 = vec_ctf(vec_unpackh(data3), 0);
alt3 = vec_ctf(vec_unpackl(data3), 0);
row4 = vec_ctf(vec_unpackh(data4), 0);
alt4 = vec_ctf(vec_unpackl(data4), 0);
row5 = vec_ctf(vec_unpackh(data5), 0);
alt5 = vec_ctf(vec_unpackl(data5), 0);
row6 = vec_ctf(vec_unpackh(data6), 0);
alt6 = vec_ctf(vec_unpackl(data6), 0);
row7 = vec_ctf(vec_unpackh(data7), 0);
alt7 = vec_ctf(vec_unpackl(data7), 0);
}
// The following block could exist as a separate an altivec dct
// function. However, if we put it inline, the DCT data can remain
// in the vector local variables, as floats, which we'll use during the
// quantize step...
{
const vector float vec_0_298631336 = (vector float)FOUROF(0.298631336f);
const vector float vec_0_390180644 = (vector float)FOUROF(-0.390180644f);
const vector float vec_0_541196100 = (vector float)FOUROF(0.541196100f);
const vector float vec_0_765366865 = (vector float)FOUROF(0.765366865f);
const vector float vec_0_899976223 = (vector float)FOUROF(-0.899976223f);
const vector float vec_1_175875602 = (vector float)FOUROF(1.175875602f);
const vector float vec_1_501321110 = (vector float)FOUROF(1.501321110f);
const vector float vec_1_847759065 = (vector float)FOUROF(-1.847759065f);
const vector float vec_1_961570560 = (vector float)FOUROF(-1.961570560f);
const vector float vec_2_053119869 = (vector float)FOUROF(2.053119869f);
const vector float vec_2_562915447 = (vector float)FOUROF(-2.562915447f);
const vector float vec_3_072711026 = (vector float)FOUROF(3.072711026f);
int whichPass, whichHalf;
for(whichPass = 1; whichPass<=2; whichPass++) {
for(whichHalf = 1; whichHalf<=2; whichHalf++) {
vector float tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
vector float tmp10, tmp11, tmp12, tmp13;
vector float z1, z2, z3, z4, z5;
tmp0 = vec_add(row0, row7); // tmp0 = dataptr[0] + dataptr[7];
tmp7 = vec_sub(row0, row7); // tmp7 = dataptr[0] - dataptr[7];
tmp3 = vec_add(row3, row4); // tmp3 = dataptr[3] + dataptr[4];
tmp4 = vec_sub(row3, row4); // tmp4 = dataptr[3] - dataptr[4];
tmp1 = vec_add(row1, row6); // tmp1 = dataptr[1] + dataptr[6];
tmp6 = vec_sub(row1, row6); // tmp6 = dataptr[1] - dataptr[6];
tmp2 = vec_add(row2, row5); // tmp2 = dataptr[2] + dataptr[5];
tmp5 = vec_sub(row2, row5); // tmp5 = dataptr[2] - dataptr[5];
tmp10 = vec_add(tmp0, tmp3); // tmp10 = tmp0 + tmp3;
tmp13 = vec_sub(tmp0, tmp3); // tmp13 = tmp0 - tmp3;
tmp11 = vec_add(tmp1, tmp2); // tmp11 = tmp1 + tmp2;
tmp12 = vec_sub(tmp1, tmp2); // tmp12 = tmp1 - tmp2;
// dataptr[0] = (DCTELEM) ((tmp10 + tmp11) << PASS1_BITS);
row0 = vec_add(tmp10, tmp11);
// dataptr[4] = (DCTELEM) ((tmp10 - tmp11) << PASS1_BITS);
row4 = vec_sub(tmp10, tmp11);
// z1 = MULTIPLY(tmp12 + tmp13, FIX_0_541196100);
z1 = vec_madd(vec_add(tmp12, tmp13), vec_0_541196100, (vector float)zero);
// dataptr[2] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp13, FIX_0_765366865),
// CONST_BITS-PASS1_BITS);
row2 = vec_madd(tmp13, vec_0_765366865, z1);
// dataptr[6] = (DCTELEM) DESCALE(z1 + MULTIPLY(tmp12, - FIX_1_847759065),
// CONST_BITS-PASS1_BITS);
row6 = vec_madd(tmp12, vec_1_847759065, z1);
z1 = vec_add(tmp4, tmp7); // z1 = tmp4 + tmp7;
z2 = vec_add(tmp5, tmp6); // z2 = tmp5 + tmp6;
z3 = vec_add(tmp4, tmp6); // z3 = tmp4 + tmp6;
z4 = vec_add(tmp5, tmp7); // z4 = tmp5 + tmp7;
// z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */
z5 = vec_madd(vec_add(z3, z4), vec_1_175875602, (vector float)zero);
// z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
z3 = vec_madd(z3, vec_1_961570560, z5);
// z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */
z4 = vec_madd(z4, vec_0_390180644, z5);
// The following adds are rolled into the multiplies above
// z3 = vec_add(z3, z5); // z3 += z5;
// z4 = vec_add(z4, z5); // z4 += z5;
// z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
// Wow! It's actually more efficient to roll this multiply
// into the adds below, even thought the multiply gets done twice!
// z2 = vec_madd(z2, vec_2_562915447, (vector float)zero);
// z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */
// Same with this one...
// z1 = vec_madd(z1, vec_0_899976223, (vector float)zero);
// tmp4 = MULTIPLY(tmp4, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
// dataptr[7] = (DCTELEM) DESCALE(tmp4 + z1 + z3, CONST_BITS-PASS1_BITS);
row7 = vec_madd(tmp4, vec_0_298631336, vec_madd(z1, vec_0_899976223, z3));
// tmp5 = MULTIPLY(tmp5, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
// dataptr[5] = (DCTELEM) DESCALE(tmp5 + z2 + z4, CONST_BITS-PASS1_BITS);
row5 = vec_madd(tmp5, vec_2_053119869, vec_madd(z2, vec_2_562915447, z4));
// tmp6 = MULTIPLY(tmp6, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
// dataptr[3] = (DCTELEM) DESCALE(tmp6 + z2 + z3, CONST_BITS-PASS1_BITS);
row3 = vec_madd(tmp6, vec_3_072711026, vec_madd(z2, vec_2_562915447, z3));
// tmp7 = MULTIPLY(tmp7, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
// dataptr[1] = (DCTELEM) DESCALE(tmp7 + z1 + z4, CONST_BITS-PASS1_BITS);
row1 = vec_madd(z1, vec_0_899976223, vec_madd(tmp7, vec_1_501321110, z4));
// Swap the row values with the alts. If this is the first half,
// this sets up the low values to be acted on in the second half.
// If this is the second half, it puts the high values back in
// the row values where they are expected to be when we're done.
SWAP(row0, alt0);
SWAP(row1, alt1);
SWAP(row2, alt2);
SWAP(row3, alt3);
SWAP(row4, alt4);
SWAP(row5, alt5);
SWAP(row6, alt6);
SWAP(row7, alt7);
}
if (whichPass == 1) {
// transpose the data for the second pass
// First, block transpose the upper right with lower left.
SWAP(row4, alt0);
SWAP(row5, alt1);
SWAP(row6, alt2);
SWAP(row7, alt3);
// Now, transpose each block of four
TRANSPOSE4(row0, row1, row2, row3);
TRANSPOSE4(row4, row5, row6, row7);
TRANSPOSE4(alt0, alt1, alt2, alt3);
TRANSPOSE4(alt4, alt5, alt6, alt7);
}
}
}
// perform the quantize step, using the floating point data
// still in the row/alt registers
{
const int* biasAddr;
const vector signed int* qmat;
vector float bias, negBias;
if (s->mb_intra) {
vector signed int baseVector;
// We must cache element 0 in the intra case
// (it needs special handling).
baseVector = vec_cts(vec_splat(row0, 0), 0);
vec_ste(baseVector, 0, &oldBaseValue);
qmat = (vector signed int*)s->q_intra_matrix[qscale];
biasAddr = &(s->intra_quant_bias);
} else {
qmat = (vector signed int*)s->q_inter_matrix[qscale];
biasAddr = &(s->inter_quant_bias);
}
// Load the bias vector (We add 0.5 to the bias so that we're
// rounding when we convert to int, instead of flooring.)
{
vector signed int biasInt;
const vector float negOneFloat = (vector float)FOUROF(-1.0f);
LOAD4(biasInt, biasAddr);
bias = vec_ctf(biasInt, QUANT_BIAS_SHIFT);
negBias = vec_madd(bias, negOneFloat, zero);
}
{
vector float q0, q1, q2, q3, q4, q5, q6, q7;
q0 = vec_ctf(qmat[0], QMAT_SHIFT);
q1 = vec_ctf(qmat[2], QMAT_SHIFT);
q2 = vec_ctf(qmat[4], QMAT_SHIFT);
q3 = vec_ctf(qmat[6], QMAT_SHIFT);
q4 = vec_ctf(qmat[8], QMAT_SHIFT);
q5 = vec_ctf(qmat[10], QMAT_SHIFT);
q6 = vec_ctf(qmat[12], QMAT_SHIFT);
q7 = vec_ctf(qmat[14], QMAT_SHIFT);
row0 = vec_sel(vec_madd(row0, q0, negBias), vec_madd(row0, q0, bias),
vec_cmpgt(row0, zero));
row1 = vec_sel(vec_madd(row1, q1, negBias), vec_madd(row1, q1, bias),
vec_cmpgt(row1, zero));
row2 = vec_sel(vec_madd(row2, q2, negBias), vec_madd(row2, q2, bias),
vec_cmpgt(row2, zero));
row3 = vec_sel(vec_madd(row3, q3, negBias), vec_madd(row3, q3, bias),
vec_cmpgt(row3, zero));
row4 = vec_sel(vec_madd(row4, q4, negBias), vec_madd(row4, q4, bias),
vec_cmpgt(row4, zero));
row5 = vec_sel(vec_madd(row5, q5, negBias), vec_madd(row5, q5, bias),
vec_cmpgt(row5, zero));
row6 = vec_sel(vec_madd(row6, q6, negBias), vec_madd(row6, q6, bias),
vec_cmpgt(row6, zero));
row7 = vec_sel(vec_madd(row7, q7, negBias), vec_madd(row7, q7, bias),
vec_cmpgt(row7, zero));
q0 = vec_ctf(qmat[1], QMAT_SHIFT);
q1 = vec_ctf(qmat[3], QMAT_SHIFT);
q2 = vec_ctf(qmat[5], QMAT_SHIFT);
q3 = vec_ctf(qmat[7], QMAT_SHIFT);
q4 = vec_ctf(qmat[9], QMAT_SHIFT);
q5 = vec_ctf(qmat[11], QMAT_SHIFT);
q6 = vec_ctf(qmat[13], QMAT_SHIFT);
q7 = vec_ctf(qmat[15], QMAT_SHIFT);
alt0 = vec_sel(vec_madd(alt0, q0, negBias), vec_madd(alt0, q0, bias),
vec_cmpgt(alt0, zero));
alt1 = vec_sel(vec_madd(alt1, q1, negBias), vec_madd(alt1, q1, bias),
vec_cmpgt(alt1, zero));
alt2 = vec_sel(vec_madd(alt2, q2, negBias), vec_madd(alt2, q2, bias),
vec_cmpgt(alt2, zero));
alt3 = vec_sel(vec_madd(alt3, q3, negBias), vec_madd(alt3, q3, bias),
vec_cmpgt(alt3, zero));
alt4 = vec_sel(vec_madd(alt4, q4, negBias), vec_madd(alt4, q4, bias),
vec_cmpgt(alt4, zero));
alt5 = vec_sel(vec_madd(alt5, q5, negBias), vec_madd(alt5, q5, bias),
vec_cmpgt(alt5, zero));
alt6 = vec_sel(vec_madd(alt6, q6, negBias), vec_madd(alt6, q6, bias),
vec_cmpgt(alt6, zero));
alt7 = vec_sel(vec_madd(alt7, q7, negBias), vec_madd(alt7, q7, bias),
vec_cmpgt(alt7, zero));
}
}
// Store the data back into the original block
{
vector signed short data0, data1, data2, data3, data4, data5, data6, data7;
data0 = vec_pack(vec_cts(row0, 0), vec_cts(alt0, 0));
data1 = vec_pack(vec_cts(row1, 0), vec_cts(alt1, 0));
data2 = vec_pack(vec_cts(row2, 0), vec_cts(alt2, 0));
data3 = vec_pack(vec_cts(row3, 0), vec_cts(alt3, 0));
data4 = vec_pack(vec_cts(row4, 0), vec_cts(alt4, 0));
data5 = vec_pack(vec_cts(row5, 0), vec_cts(alt5, 0));
data6 = vec_pack(vec_cts(row6, 0), vec_cts(alt6, 0));
data7 = vec_pack(vec_cts(row7, 0), vec_cts(alt7, 0));
{
// Clamp for overflow
vector signed int max_q_int, min_q_int;
vector signed short max_q, min_q;
LOAD4(max_q_int, &(s->max_qcoeff));
LOAD4(min_q_int, &(s->min_qcoeff));
max_q = vec_pack(max_q_int, max_q_int);
min_q = vec_pack(min_q_int, min_q_int);
data0 = vec_max(vec_min(data0, max_q), min_q);
data1 = vec_max(vec_min(data1, max_q), min_q);
data2 = vec_max(vec_min(data2, max_q), min_q);
data4 = vec_max(vec_min(data4, max_q), min_q);
data5 = vec_max(vec_min(data5, max_q), min_q);
data6 = vec_max(vec_min(data6, max_q), min_q);
data7 = vec_max(vec_min(data7, max_q), min_q);
}
{
vector bool char zero_01, zero_23, zero_45, zero_67;
vector signed char scanIndexes_01, scanIndexes_23, scanIndexes_45, scanIndexes_67;
vector signed char negOne = vec_splat_s8(-1);
vector signed char* scanPtr =
(vector signed char*)(s->intra_scantable.inverse);
signed char lastNonZeroChar;
// Determine the largest non-zero index.
zero_01 = vec_pack(vec_cmpeq(data0, (vector signed short)zero),
vec_cmpeq(data1, (vector signed short)zero));
zero_23 = vec_pack(vec_cmpeq(data2, (vector signed short)zero),
vec_cmpeq(data3, (vector signed short)zero));
zero_45 = vec_pack(vec_cmpeq(data4, (vector signed short)zero),
vec_cmpeq(data5, (vector signed short)zero));
zero_67 = vec_pack(vec_cmpeq(data6, (vector signed short)zero),
vec_cmpeq(data7, (vector signed short)zero));
// 64 biggest values
scanIndexes_01 = vec_sel(scanPtr[0], negOne, zero_01);
scanIndexes_23 = vec_sel(scanPtr[1], negOne, zero_23);
scanIndexes_45 = vec_sel(scanPtr[2], negOne, zero_45);
scanIndexes_67 = vec_sel(scanPtr[3], negOne, zero_67);
// 32 largest values
scanIndexes_01 = vec_max(scanIndexes_01, scanIndexes_23);
scanIndexes_45 = vec_max(scanIndexes_45, scanIndexes_67);
// 16 largest values
scanIndexes_01 = vec_max(scanIndexes_01, scanIndexes_45);
// 8 largest values
scanIndexes_01 = vec_max(vec_mergeh(scanIndexes_01, negOne),
vec_mergel(scanIndexes_01, negOne));
// 4 largest values
scanIndexes_01 = vec_max(vec_mergeh(scanIndexes_01, negOne),
vec_mergel(scanIndexes_01, negOne));
// 2 largest values
scanIndexes_01 = vec_max(vec_mergeh(scanIndexes_01, negOne),
vec_mergel(scanIndexes_01, negOne));
// largest value
scanIndexes_01 = vec_max(vec_mergeh(scanIndexes_01, negOne),
vec_mergel(scanIndexes_01, negOne));
scanIndexes_01 = vec_splat(scanIndexes_01, 0);
vec_ste(scanIndexes_01, 0, &lastNonZeroChar);
lastNonZero = lastNonZeroChar;
// While the data is still in vectors we check for the transpose IDCT permute
// and handle it using the vector unit if we can. This is the permute used
// by the altivec idct, so it is common when using the altivec dct.
if ((lastNonZero > 0) && (s->dsp.idct_permutation_type == FF_TRANSPOSE_IDCT_PERM)) {
TRANSPOSE8(data0, data1, data2, data3, data4, data5, data6, data7);
}
vec_st(data0, 0, data);
vec_st(data1, 16, data);
vec_st(data2, 32, data);
vec_st(data3, 48, data);
vec_st(data4, 64, data);
vec_st(data5, 80, data);
vec_st(data6, 96, data);
vec_st(data7, 112, data);
}
}
// special handling of block[0]
if (s->mb_intra) {
if (!s->h263_aic) {
if (n < 4)
oldBaseValue /= s->y_dc_scale;
else
oldBaseValue /= s->c_dc_scale;
}
// Divide by 8, rounding the result
data[0] = (oldBaseValue + 4) >> 3;
}
// We handled the transpose permutation above and we don't
// need to permute the "no" permutation case.
if ((lastNonZero > 0) &&
(s->dsp.idct_permutation_type != FF_TRANSPOSE_IDCT_PERM) &&
(s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)) {
ff_block_permute(data, s->dsp.idct_permutation,
s->intra_scantable.scantable, lastNonZero);
}
return lastNonZero;
}
int
__open_catalog (const char *cat_name, const char *nlspath, const char *env_var,
__nl_catd catalog)
{
int fd = -1;
struct stat64 st;
int swapping;
size_t cnt;
size_t max_offset;
size_t tab_size;
const char *lastp;
int result = -1;
if (strchr (cat_name, '/') != NULL || nlspath == NULL)
fd = open_not_cancel_2 (cat_name, O_RDONLY);
else
{
const char *run_nlspath = nlspath;
#define ENOUGH(n) \
if (__builtin_expect (bufact + (n) >= bufmax, 0)) \
{ \
char *old_buf = buf; \
bufmax += 256 + (n); \
buf = (char *) alloca (bufmax); \
memcpy (buf, old_buf, bufact); \
}
/* The RUN_NLSPATH variable contains a colon separated list of
descriptions where we expect to find catalogs. We have to
recognize certain % substitutions and stop when we found the
first existing file. */
char *buf;
size_t bufact;
size_t bufmax;
size_t len;
buf = NULL;
bufmax = 0;
fd = -1;
while (*run_nlspath != '\0')
{
bufact = 0;
if (*run_nlspath == ':')
{
/* Leading colon or adjacent colons - treat same as %N. */
len = strlen (cat_name);
ENOUGH (len);
memcpy (&buf[bufact], cat_name, len);
bufact += len;
}
else
while (*run_nlspath != ':' && *run_nlspath != '\0')
if (*run_nlspath == '%')
{
const char *tmp;
++run_nlspath; /* We have seen the `%'. */
switch (*run_nlspath++)
{
case 'N':
/* Use the catalog name. */
len = strlen (cat_name);
ENOUGH (len);
memcpy (&buf[bufact], cat_name, len);
bufact += len;
break;
case 'L':
/* Use the current locale category value. */
len = strlen (env_var);
ENOUGH (len);
memcpy (&buf[bufact], env_var, len);
bufact += len;
break;
case 'l':
/* Use language element of locale category value. */
tmp = env_var;
do
{
ENOUGH (1);
buf[bufact++] = *tmp++;
}
while (*tmp != '\0' && *tmp != '_' && *tmp != '.');
break;
case 't':
/* Use territory element of locale category value. */
tmp = env_var;
do
++tmp;
while (*tmp != '\0' && *tmp != '_' && *tmp != '.');
if (*tmp == '_')
{
++tmp;
do
{
ENOUGH (1);
buf[bufact++] = *tmp++;
}
while (*tmp != '\0' && *tmp != '.');
}
break;
case 'c':
/* Use code set element of locale category value. */
tmp = env_var;
do
++tmp;
while (*tmp != '\0' && *tmp != '.');
if (*tmp == '.')
{
++tmp;
do
{
ENOUGH (1);
buf[bufact++] = *tmp++;
}
while (*tmp != '\0');
}
break;
case '%':
ENOUGH (1);
buf[bufact++] = '%';
break;
default:
/* Unknown variable: ignore this path element. */
bufact = 0;
while (*run_nlspath != '\0' && *run_nlspath != ':')
++run_nlspath;
break;
}
}
else
{
ENOUGH (1);
buf[bufact++] = *run_nlspath++;
}
ENOUGH (1);
buf[bufact] = '\0';
if (bufact != 0)
{
fd = open_not_cancel_2 (buf, O_RDONLY);
if (fd >= 0)
break;
}
++run_nlspath;
}
}
/* Avoid dealing with directories and block devices */
if (__builtin_expect (fd, 0) < 0)
return -1;
if (__builtin_expect (__fxstat64 (_STAT_VER, fd, &st), 0) < 0)
goto close_unlock_return;
if (__builtin_expect (!S_ISREG (st.st_mode), 0)
|| (size_t) st.st_size < sizeof (struct catalog_obj))
{
/* `errno' is not set correctly but the file is not usable.
Use an reasonable error value. */
__set_errno (EINVAL);
goto close_unlock_return;
}
catalog->file_size = st.st_size;
#ifdef _POSIX_MAPPED_FILES
# ifndef MAP_COPY
/* Linux seems to lack read-only copy-on-write. */
# define MAP_COPY MAP_PRIVATE
# endif
# ifndef MAP_FILE
/* Some systems do not have this flag; it is superfluous. */
# define MAP_FILE 0
# endif
catalog->file_ptr =
(struct catalog_obj *) __mmap (NULL, st.st_size, PROT_READ,
MAP_FILE|MAP_COPY, fd, 0);
if (__builtin_expect (catalog->file_ptr != (struct catalog_obj *) MAP_FAILED,
1))
/* Tell the world we managed to mmap the file. */
catalog->status = mmapped;
else
#endif /* _POSIX_MAPPED_FILES */
{
/* mmap failed perhaps because the system call is not
implemented. Try to load the file. */
size_t todo;
catalog->file_ptr = malloc (st.st_size);
if (catalog->file_ptr == NULL)
goto close_unlock_return;
todo = st.st_size;
/* Save read, handle partial reads. */
do
{
size_t now = read_not_cancel (fd, (((char *) catalog->file_ptr)
+ (st.st_size - todo)), todo);
if (now == 0 || now == (size_t) -1)
{
#ifdef EINTR
if (now == (size_t) -1 && errno == EINTR)
continue;
#endif
free ((void *) catalog->file_ptr);
goto close_unlock_return;
}
todo -= now;
}
while (todo > 0);
catalog->status = malloced;
}
/* Determine whether the file is a catalog file and if yes whether
it is written using the correct byte order. Else we have to swap
the values. */
if (__builtin_expect (catalog->file_ptr->magic == CATGETS_MAGIC, 1))
swapping = 0;
else if (catalog->file_ptr->magic == SWAPU32 (CATGETS_MAGIC))
swapping = 1;
else
{
invalid_file:
/* Invalid file. Free the resources and mark catalog as not
usable. */
#ifdef _POSIX_MAPPED_FILES
if (catalog->status == mmapped)
__munmap ((void *) catalog->file_ptr, catalog->file_size);
else
#endif /* _POSIX_MAPPED_FILES */
free (catalog->file_ptr);
goto close_unlock_return;
}
#define SWAP(x) (swapping ? SWAPU32 (x) : (x))
/* Get dimensions of the used hashing table. */
catalog->plane_size = SWAP (catalog->file_ptr->plane_size);
catalog->plane_depth = SWAP (catalog->file_ptr->plane_depth);
/* The file contains two versions of the pointer tables. Pick the
right one for the local byte order. */
#if __BYTE_ORDER == __LITTLE_ENDIAN
catalog->name_ptr = &catalog->file_ptr->name_ptr[0];
#elif __BYTE_ORDER == __BIG_ENDIAN
catalog->name_ptr = &catalog->file_ptr->name_ptr[catalog->plane_size
* catalog->plane_depth
* 3];
#else
# error Cannot handle __BYTE_ORDER byte order
#endif
/* The rest of the file contains all the strings. They are
addressed relative to the position of the first string. */
catalog->strings =
(const char *) &catalog->file_ptr->name_ptr[catalog->plane_size
* catalog->plane_depth * 3 * 2];
/* Determine the largest string offset mentioned in the table. */
max_offset = 0;
tab_size = 3 * catalog->plane_size * catalog->plane_depth;
for (cnt = 2; cnt < tab_size; cnt += 3)
if (catalog->name_ptr[cnt] > max_offset)
max_offset = catalog->name_ptr[cnt];
/* Now we can check whether the file is large enough to contain the
tables it says it contains. */
if ((size_t) st.st_size
<= (sizeof (struct catalog_obj) + 2 * tab_size + max_offset))
/* The last string is not contained in the file. */
goto invalid_file;
lastp = catalog->strings + max_offset;
max_offset = (st.st_size
- sizeof (struct catalog_obj) + 2 * tab_size + max_offset);
while (*lastp != '\0')
{
if (--max_offset == 0)
goto invalid_file;
++lastp;
}
/* We succeeded. */
result = 0;
/* Release the lock again. */
close_unlock_return:
close_not_cancel_no_status (fd);
return result;
}
void ldb_qsort (void *const pbase, size_t total_elems, size_t size,
void *opaque, ldb_qsort_cmp_fn_t cmp)
{
register char *base_ptr = (char *) pbase;
const size_t max_thresh = MAX_THRESH * size;
if (total_elems == 0)
/* Avoid lossage with unsigned arithmetic below. */
return;
if (total_elems > MAX_THRESH)
{
char *lo = base_ptr;
char *hi = &lo[size * (total_elems - 1)];
stack_node stack[STACK_SIZE];
stack_node *top = stack;
PUSH (NULL, NULL);
while (STACK_NOT_EMPTY)
{
char *left_ptr;
char *right_ptr;
/* Select median value from among LO, MID, and HI. Rearrange
LO and HI so the three values are sorted. This lowers the
probability of picking a pathological pivot value and
skips a comparison for both the LEFT_PTR and RIGHT_PTR in
the while loops. */
char *mid = lo + size * ((hi - lo) / size >> 1);
if ((*cmp) ((void *) mid, (void *) lo, opaque) < 0)
SWAP (mid, lo, size);
if ((*cmp) ((void *) hi, (void *) mid, opaque) < 0)
SWAP (mid, hi, size);
else
goto jump_over;
if ((*cmp) ((void *) mid, (void *) lo, opaque) < 0)
SWAP (mid, lo, size);
jump_over:;
left_ptr = lo + size;
right_ptr = hi - size;
/* Here's the famous ``collapse the walls'' section of quicksort.
Gotta like those tight inner loops! They are the main reason
that this algorithm runs much faster than others. */
do
{
while ((*cmp) ((void *) left_ptr, (void *) mid, opaque) < 0)
left_ptr += size;
while ((*cmp) ((void *) mid, (void *) right_ptr, opaque) < 0)
right_ptr -= size;
if (left_ptr < right_ptr)
{
SWAP (left_ptr, right_ptr, size);
if (mid == left_ptr)
mid = right_ptr;
else if (mid == right_ptr)
mid = left_ptr;
left_ptr += size;
right_ptr -= size;
}
else if (left_ptr == right_ptr)
{
left_ptr += size;
right_ptr -= size;
break;
}
}
while (left_ptr <= right_ptr);
/* Set up pointers for next iteration. First determine whether
left and right partitions are below the threshold size. If so,
ignore one or both. Otherwise, push the larger partition's
bounds on the stack and continue sorting the smaller one. */
if ((size_t) (right_ptr - lo) <= max_thresh)
{
if ((size_t) (hi - left_ptr) <= max_thresh)
/* Ignore both small partitions. */
POP (lo, hi);
else
/* Ignore small left partition. */
lo = left_ptr;
}
else if ((size_t) (hi - left_ptr) <= max_thresh)
/* Ignore small right partition. */
hi = right_ptr;
else if ((right_ptr - lo) > (hi - left_ptr))
{
/* Push larger left partition indices. */
PUSH (lo, right_ptr);
lo = left_ptr;
}
else
{
/* Push larger right partition indices. */
PUSH (left_ptr, hi);
hi = right_ptr;
}
}
}
void AnimatedSprite3D::_draw() {
RID immediate = get_immediate();
VS::get_singleton()->immediate_clear(immediate);
if (frames.is_null()) {
return;
}
if (frame < 0) {
return;
}
if (!frames->has_animation(animation)) {
return;
}
Ref<Texture> texture = frames->get_frame(animation, frame);
if (!texture.is_valid())
return; //no texuture no life
Vector2 tsize = texture->get_size();
if (tsize.x == 0 || tsize.y == 0)
return;
Size2i s = tsize;
Rect2 src_rect;
src_rect.size = s;
Point2 ofs = get_offset();
if (is_centered())
ofs -= s / 2;
Rect2 dst_rect(ofs, s);
Rect2 final_rect;
Rect2 final_src_rect;
if (!texture->get_rect_region(dst_rect, src_rect, final_rect, final_src_rect))
return;
if (final_rect.size.x == 0 || final_rect.size.y == 0)
return;
Color color = _get_color_accum();
color.a *= get_opacity();
float pixel_size = get_pixel_size();
Vector2 vertices[4] = {
(final_rect.position + Vector2(0, final_rect.size.y)) * pixel_size,
(final_rect.position + final_rect.size) * pixel_size,
(final_rect.position + Vector2(final_rect.size.x, 0)) * pixel_size,
final_rect.position * pixel_size,
};
Vector2 src_tsize = tsize;
// Properly setup UVs for impostor textures (AtlasTexture).
Ref<AtlasTexture> atlas_tex = texture;
if (atlas_tex != NULL) {
src_tsize[0] = atlas_tex->get_atlas()->get_width();
src_tsize[1] = atlas_tex->get_atlas()->get_height();
}
Vector2 uvs[4] = {
final_src_rect.position / src_tsize,
(final_src_rect.position + Vector2(final_src_rect.size.x, 0)) / src_tsize,
(final_src_rect.position + final_src_rect.size) / src_tsize,
(final_src_rect.position + Vector2(0, final_src_rect.size.y)) / src_tsize,
};
if (is_flipped_h()) {
SWAP(uvs[0], uvs[1]);
SWAP(uvs[2], uvs[3]);
}
if (is_flipped_v()) {
SWAP(uvs[0], uvs[3]);
SWAP(uvs[1], uvs[2]);
}
Vector3 normal;
int axis = get_axis();
normal[axis] = 1.0;
Plane tangent;
if (axis == Vector3::AXIS_X) {
tangent = Plane(0, 0, -1, -1);
} else {
tangent = Plane(1, 0, 0, -1);
}
RID mat = SpatialMaterial::get_material_rid_for_2d(get_draw_flag(FLAG_SHADED), get_draw_flag(FLAG_TRANSPARENT), get_draw_flag(FLAG_DOUBLE_SIDED), get_alpha_cut_mode() == ALPHA_CUT_DISCARD, get_alpha_cut_mode() == ALPHA_CUT_OPAQUE_PREPASS);
VS::get_singleton()->immediate_set_material(immediate, mat);
VS::get_singleton()->immediate_begin(immediate, VS::PRIMITIVE_TRIANGLE_FAN, texture->get_rid());
int x_axis = ((axis + 1) % 3);
int y_axis = ((axis + 2) % 3);
if (axis != Vector3::AXIS_Z) {
SWAP(x_axis, y_axis);
for (int i = 0; i < 4; i++) {
//uvs[i] = Vector2(1.0,1.0)-uvs[i];
//SWAP(vertices[i].x,vertices[i].y);
if (axis == Vector3::AXIS_Y) {
vertices[i].y = -vertices[i].y;
} else if (axis == Vector3::AXIS_X) {
vertices[i].x = -vertices[i].x;
}
}
}
AABB aabb;
for (int i = 0; i < 4; i++) {
VS::get_singleton()->immediate_normal(immediate, normal);
VS::get_singleton()->immediate_tangent(immediate, tangent);
VS::get_singleton()->immediate_color(immediate, color);
VS::get_singleton()->immediate_uv(immediate, uvs[i]);
Vector3 vtx;
vtx[x_axis] = vertices[i][0];
vtx[y_axis] = vertices[i][1];
VS::get_singleton()->immediate_vertex(immediate, vtx);
if (i == 0) {
aabb.position = vtx;
aabb.size = Vector3();
} else {
aabb.expand_to(vtx);
}
}
set_aabb(aabb);
VS::get_singleton()->immediate_end(immediate);
}
gmx_bool gaussj(real **a, int n, real **b, int m)
{
int *indxc, *indxr, *ipiv;
int i, icol = 0, irow = 0, j, k, l, ll;
real big, dum, pivinv;
indxc = ivector(1, n);
indxr = ivector(1, n);
ipiv = ivector(1, n);
for (j = 1; j <= n; j++)
{
ipiv[j] = 0;
}
for (i = 1; i <= n; i++)
{
big = 0.0;
for (j = 1; j <= n; j++)
{
if (ipiv[j] != 1)
{
for (k = 1; k <= n; k++)
{
if (ipiv[k] == 0)
{
if (fabs(a[j][k]) >= big)
{
big = fabs(a[j][k]);
irow = j;
icol = k;
}
}
else if (ipiv[k] > 1)
{
nrerror("GAUSSJ: Singular Matrix-1", FALSE);
return FALSE;
}
}
}
}
++(ipiv[icol]);
if (irow != icol)
{
for (l = 1; l <= n; l++)
{
SWAP(a[irow][l], a[icol][l]);
}
for (l = 1; l <= m; l++)
{
SWAP(b[irow][l], b[icol][l]);
}
}
indxr[i] = irow;
indxc[i] = icol;
if (a[icol][icol] == 0.0)
{
fprintf(stderr, "irow = %d, icol = %d\n", irow, icol);
dump_mat(n, a);
nrerror("GAUSSJ: Singular Matrix-2", FALSE);
return FALSE;
}
pivinv = 1.0/a[icol][icol];
a[icol][icol] = 1.0;
for (l = 1; l <= n; l++)
{
a[icol][l] *= pivinv;
}
for (l = 1; l <= m; l++)
{
b[icol][l] *= pivinv;
}
for (ll = 1; ll <= n; ll++)
{
if (ll != icol)
{
dum = a[ll][icol];
a[ll][icol] = 0.0;
for (l = 1; l <= n; l++)
{
a[ll][l] -= a[icol][l]*dum;
}
for (l = 1; l <= m; l++)
{
b[ll][l] -= b[icol][l]*dum;
}
}
}
}
for (l = n; l >= 1; l--)
{
if (indxr[l] != indxc[l])
{
for (k = 1; k <= n; k++)
{
SWAP(a[k][indxr[l]], a[k][indxc[l]]);
}
}
}
free_ivector(ipiv, 1);
free_ivector(indxr, 1);
free_ivector(indxc, 1);
return TRUE;
}
/*==========================================
* is ranged attack from (x0,y0) to (x1,y1) possible?
*------------------------------------------*/
bool path_search_long(struct shootpath_data *spd,int16 m,int16 x0,int16 y0,int16 x1,int16 y1,cell_chk cell)
{
int dx, dy;
int wx = 0, wy = 0;
int weight;
struct map_data *md;
struct shootpath_data s_spd;
if( spd == NULL )
spd = &s_spd; // use dummy output variable
if (!map[m].cell)
return false;
md = &map[m];
dx = (x1 - x0);
if (dx < 0) {
SWAP(x0, x1);
SWAP(y0, y1);
dx = -dx;
}
dy = (y1 - y0);
spd->rx = spd->ry = 0;
spd->len = 1;
spd->x[0] = x0;
spd->y[0] = y0;
if (dx > abs(dy)) {
weight = dx;
spd->ry = 1;
} else {
weight = abs(y1 - y0);
spd->rx = 1;
}
while (x0 != x1 || y0 != y1)
{
wx += dx;
wy += dy;
if (wx >= weight) {
wx -= weight;
x0++;
}
if (wy >= weight) {
wy -= weight;
y0++;
} else if (wy < 0) {
wy += weight;
y0--;
}
if( spd->len<MAX_WALKPATH )
{
spd->x[spd->len] = x0;
spd->y[spd->len] = y0;
spd->len++;
}
if ((x0 != x1 || y0 != y1) && map_getcellp(md,x0,y0,cell))
return false;
}
return true;
}
static void
reverse(Cable *cable) {
SWAP(cable->c1, cable->c2);
SWAP(cable->x1, cable->x2);
SWAP(cable->y1, cable->y2);
}
////////////////////////////////////////////////////////////////////////////////////////
// CreateStrips()
//
// Generates actual strips from the list-in-strip-order.
//
void NvStripifier::CreateStrips(const NvStripInfoVec& allStrips, IntVec& stripIndices,
const bool bStitchStrips, unsigned int& numSeparateStrips)
{
assert(numSeparateStrips == 0);
NvFaceInfo tLastFace(0, 0, 0);
int nStripCount = allStrips.size();
assert(nStripCount > 0);
//we infer the cw/ccw ordering depending on the number of indices
//this is screwed up by the fact that we insert -1s to denote changing strips
//this is to account for that
int accountForNegatives = 0;
for (int i = 0; i < nStripCount; i++)
{
NvStripInfo *strip = allStrips[i];
int nStripFaceCount = strip->m_faces.size();
assert(nStripFaceCount > 0);
// Handle the first face in the strip
{
NvFaceInfo tFirstFace(strip->m_faces[0]->m_v0, strip->m_faces[0]->m_v1, strip->m_faces[0]->m_v2);
// If there is a second face, reorder vertices such that the
// unique vertex is first
if (nStripFaceCount > 1)
{
int nUnique = NvStripifier::GetUniqueVertexInB(strip->m_faces[1], &tFirstFace);
if (nUnique == tFirstFace.m_v1)
{
SWAP(tFirstFace.m_v0, tFirstFace.m_v1);
}
else if (nUnique == tFirstFace.m_v2)
{
SWAP(tFirstFace.m_v0, tFirstFace.m_v2);
}
// If there is a third face, reorder vertices such that the
// shared vertex is last
if (nStripFaceCount > 2)
{
int nShared = GetSharedVertex(strip->m_faces[2], &tFirstFace);
if (nShared == tFirstFace.m_v1)
{
SWAP(tFirstFace.m_v1, tFirstFace.m_v2);
}
}
}
if( (i == 0) || !bStitchStrips)
{
if(!IsCW(strip->m_faces[0], tFirstFace.m_v0, tFirstFace.m_v1))
stripIndices.push_back(tFirstFace.m_v0);
}
else
{
// Double tap the first in the _new strip
stripIndices.push_back(tFirstFace.m_v0);
// Check CW/CCW ordering
if (NextIsCW(stripIndices.size() - accountForNegatives) != IsCW(strip->m_faces[0], tFirstFace.m_v0, tFirstFace.m_v1))
{
stripIndices.push_back(tFirstFace.m_v0);
}
}
stripIndices.push_back(tFirstFace.m_v0);
stripIndices.push_back(tFirstFace.m_v1);
stripIndices.push_back(tFirstFace.m_v2);
// Update last face info
tLastFace = tFirstFace;
}
for (int j = 1; j < nStripFaceCount; j++)
{
int nUnique = GetUniqueVertexInB(&tLastFace, strip->m_faces[j]);
if (nUnique != -1)
{
stripIndices.push_back(nUnique);
// Update last face info
tLastFace.m_v0 = tLastFace.m_v1;
tLastFace.m_v1 = tLastFace.m_v2;
tLastFace.m_v2 = nUnique;
}
}
// Double tap between strips.
if(bStitchStrips)
{
if(i != nStripCount - 1)
stripIndices.push_back(tLastFace.m_v2);
}
else
{
//-1 index indicates next strip
stripIndices.push_back(-1);
accountForNegatives++;
numSeparateStrips++;
}
// Update last face info
tLastFace.m_v0 = tLastFace.m_v1;
tLastFace.m_v1 = tLastFace.m_v2;
tLastFace.m_v2 = tLastFace.m_v2;
}
if(bStitchStrips)
numSeparateStrips = 1;
}
void lin_alg::row_reduce(double **A, double *b, double **Aug, int *nrow, int rows, bool pivoting)
{
// This function takes a square matrix A, rhs vector b and performs
// a row reduction on the augmented matrix Aug = [A:b]
// The augmented matrix should be in upper triangular form at the end of the function
// Use these variables to determine the max pivot element
int piv_indx;
double pivot,pivcomp;
double m; // row multiplier
// 1. Use Aug to store the elements of A and b
for(int i=1; i<=rows; i++){
for(int j=1; j<=rows; j++){
Aug[i][j] = A[i][j];
}
}
// 2. Add the rhs vector to the last column
for(int i=1; i<=rows; i++){
Aug[i][rows+1] = b[i];
}
// 3. Store the index of each of the rows as they are entered in the matrix
// This will be used to keep track of the row interchanges
for(int i=1; i<=rows; i++){
nrow[i] = i;
}
// Main loop
for(int i=1; i<=rows-1; i++){
// Choose the pivot element
// Search column i for the largest value by absolute value
pivot = 0.0;
for(int k=i; k <= rows; k++){
pivcomp = fabs(Aug[ nrow[k] ][i]);
// This is the search portion
if(pivcomp > fabs(pivot)){
pivot = pivcomp; // store the pivot element
piv_indx = k;
}
}
// simulate a row interchange if required
if(pivoting && !(nrow[i] == nrow[piv_indx])){
SWAP(nrow[i], nrow[piv_indx]);
}
// Perform the ERO
for(int j=i+1; j<=rows; j++){
m = (Aug[ nrow[j] ][i] / Aug[ nrow[i] ][i]); // Compute the row multiplier, the computer accesses the pivot numer via nrow
for(int c = 1; c<= rows+1; c++){
Aug[ nrow[j] ][c] = Aug[ nrow[j] ][c] -( m * Aug[ nrow[i] ][c] ); // perform the ERO
}
}
}
}
layer_colorbase[2] = 0x80;
layer_colorbase[3] = 0xc0;
}
/* useful function to sort the three tile layers by priority order */
static void sortlayers(int *layer,int *pri)
{
#define SWAP(a,b) \
if (pri[a] < pri[b]) \
{ \
int t; \
t = pri[a]; pri[a] = pri[b]; pri[b] = t; \
t = layer[a]; layer[a] = layer[b]; layer[b] = t; \
}
SWAP(0,1)
SWAP(0,2)
SWAP(0,3)
SWAP(1,2)
SWAP(1,3)
SWAP(2,3)
}
VIDEO_UPDATE(bishi)
{
int layers[4], i;/*, old;*/
/* int bg_colorbase, new_colorbase, plane, dirty; */
static const int pris[4] = { K55_PRIINP_0, K55_PRIINP_3, K55_PRIINP_6, K55_PRIINP_7 };
static const int enables[4] = { K55_INP_VRAM_A, K55_INP_VRAM_B, K55_INP_VRAM_C, K55_INP_VRAM_D };
K054338_update_all_shadows(screen->machine);
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include "sha1.h"
#define SWAP(x) (((x) >> 24) | (((x)&0x00FF0000) >> 8) | (((x)&0x0000FF00) << 8) | (x << 24))
const uint32_t message0[SHA1_STEP_SIZE] = {
SWAP(0x61626380), SWAP(0x00000000), SWAP(0x00000000), SWAP(0x00000000),
SWAP(0x00000000), SWAP(0x00000000), SWAP(0x00000000), SWAP(0x00000000),
SWAP(0x00000000), SWAP(0x00000000), SWAP(0x00000000), SWAP(0x00000000),
SWAP(0x00000000), SWAP(0x00000000), SWAP(0x00000000), SWAP(0x00000018)
};
const uint32_t H_expected0[SHA1_HASH_SIZE] = {
0xa9993e36, 0x4706816a, 0xba3e2571, 0x7850c26c, 0x9cd0d89d
};
const uint32_t message1[2*SHA1_STEP_SIZE] = {
SWAP(0x61626364), SWAP(0x62636465), SWAP(0x63646566), SWAP(0x64656667),
SWAP(0x65666768), SWAP(0x66676869), SWAP(0x6768696a), SWAP(0x68696a6b),
SWAP(0x696a6b6c), SWAP(0x6a6b6c6d), SWAP(0x6b6c6d6e), SWAP(0x6c6d6e6f),
SWAP(0x6d6e6f70), SWAP(0x6e6f7071), SWAP(0x80000000), SWAP(0x00000000),
void dens_step ( int N, float * x, float * x0, float * u, float * v, float diff, float dt )
{
add_source ( N, x, x0, dt );
SWAP ( x0, x ); diffuse ( N, 0, x, x0, diff, dt );
SWAP ( x0, x ); advect ( N, 0, x, x0, u, v, dt );
}
void iindexx(unsigned long n, long arr[], unsigned long indx[])
{
unsigned long i,indxt,ir=n,itemp,j,k,l=1;
int jstack=0,*istack;
long a;
istack=ivector(1,NSTACK);
for (j=1;j<=n;j++) indx[j]=j;
for (;;) {
if (ir-l < M) {
for (j=l+1;j<=ir;j++) {
indxt=indx[j];
a=arr[indxt];
for (i=j-1;i>=1;i--) {
if (arr[indx[i]] <= a) break;
indx[i+1]=indx[i];
}
indx[i+1]=indxt;
}
if (jstack == 0) break;
ir=istack[jstack--];
l=istack[jstack--];
} else {
k=(l+ir) >> 1;
SWAP(indx[k],indx[l+1]);
if (arr[indx[l+1]] > arr[indx[ir]]) {
SWAP(indx[l+1],indx[ir])
}
if (arr[indx[l]] > arr[indx[ir]]) {
SWAP(indx[l],indx[ir])
}
if (arr[indx[l+1]] > arr[indx[l]]) {
SWAP(indx[l+1],indx[l])
}
i=l+1;
j=ir;
indxt=indx[l];
a=arr[indxt];
for (;;) {
do i++; while (arr[indx[i]] < a);
do j--; while (arr[indx[j]] > a);
if (j < i) break;
SWAP(indx[i],indx[j])
}
indx[l]=indx[j];
indx[j]=indxt;
jstack += 2;
if (jstack > NSTACK) nrerror("NSTACK too small in iindexx.");
if (ir-i+1 >= j-l) {
istack[jstack]=ir;
istack[jstack-1]=i;
ir=j-1;
} else {
istack[jstack]=j-1;
istack[jstack-1]=l;
l=i;
}
}
}
free_ivector(istack,1,NSTACK);
}
int CIOlib::gread(
int fd, /*file descriptor*/
byte *in_buf, /*bufer to read/cast data to*/
enum data_types disk_dt, /*type of data on disk*/
enum data_types in_dt, /*type of data to cast to*/
int nobj, /*number of objects*/
enum yin_yang swap /*swap flag*/
){
char *chr_ptr, /*pointer to char*/
*aflt_ptr; /*pointer to ascii floats*/
short *srt_ptr; /*pointer to shorts*/
unsigned short *usrt_ptr; /*pointer to unsigned short*/
unsigned char *uch_ptr, /*pointer to unsigned character*/
*tmp_buf, /*temporary buffer*/
tmp_byte; /*temporary character buffer*/
int *int_ptr; /*pointer to integer*/
unsigned long *ulng_ptr; /*pointer to unsigned long*/
long *lng_ptr; /*pointer to long*/
unsigned i,n1,n2, /*looping varables*/
disk_size, /*num of bytes in disk_dt*/
in_size, /*num of bytes in in_dt*/
tot_num_read, /*total number of bytes read*/
num_read = 0; /*number of bytes read*/
float *flt_ptr; /*pointer to float*/
double *dbl_ptr, /*pointer to double*/
dbl_tmp; /*double temp space*/
/*Set parameters for different disk_buf data types.*/
switch( disk_dt ){
case UCH:
disk_size = sizeof(unsigned char);
break;
case CHR:
disk_size = sizeof(char);
break;
case USRT:
disk_size = sizeof(unsigned short);
break;
case SRT:
disk_size = sizeof(short);
break;
case dsINT:
disk_size = sizeof(int);
break;
case LNG:
disk_size = sizeof(long);
break;
case ULNG:
disk_size = sizeof(unsigned long);
break;
case FLT:
disk_size = sizeof(float);
break;
case DBL:
disk_size = sizeof(double);
break;
case SPECIAL_AFLT:
disk_size = SPECIAL_ASCII_FLT_SIZE;
break;
default:
return(-1);
}/*switch*/
/*Set parameters for different in_buf data types.*/
switch( in_dt ){
case CHR:
in_size = sizeof(char);
chr_ptr = (char *)in_buf;
break;
case UCH:
in_size = sizeof(unsigned char);
uch_ptr = in_buf;
break;
case USRT:
in_size = sizeof(unsigned short);
usrt_ptr = (unsigned short *)in_buf;
break;
case SRT:
in_size = sizeof(short);
srt_ptr = (short *)in_buf;
break;
case dsINT:
in_size = sizeof(int);
int_ptr = (int *)in_buf;
break;
case LNG:
in_size = sizeof(long);
lng_ptr = (long *)in_buf;
break;
case ULNG:
in_size = sizeof(unsigned long);
ulng_ptr = (unsigned long *)in_buf;
break;
case FLT:
in_size = sizeof(float);
flt_ptr = (float *)in_buf;
break;
case DBL:
in_size = sizeof(double);
dbl_ptr = (double *)in_buf;
break;
default:
return(-1);
}/*switch*/
if( in_size != disk_size ){
/*Allocate memory for temporary buffer to read disk data into.*/
tmp_buf = (unsigned char *)calloc(BUFSIZ,disk_size);
if( tmp_buf == 0 ){
return -1;
}/*if*/
n1 = nobj;
tot_num_read = 0;
while( (n2 = MIN(n1,BUFSIZ)) > 0 ){
#ifdef SRC_UNIX
if( (num_read = read(fd,tmp_buf,n2*disk_size)) != n2*disk_size )
#endif
#ifdef SRC_NT
if( (num_read = _read(fd,tmp_buf,n2*disk_size)) != n2*disk_size )
#endif
if( num_read != 0 ){
return -1;
}
else return 0;
tot_num_read += num_read;
/*Swap data if requested.*/
if( swap == YES ){
if( disk_dt == SRT || disk_dt == USRT ){
for(i=0; i<n2; i++)
{
SWAP( (*(tmp_buf + i*2)), (*(tmp_buf + i*2 + 1)), tmp_byte);
}
}
}
switch(disk_dt){
case UCH:
uch_ptr = tmp_buf;
switch(in_dt){
case USRT:
for(i=0; i<n2; i++) *usrt_ptr++ = (unsigned short)*uch_ptr++;
break;
case dsINT:
for(i=0; i<n2; i++) *int_ptr++ = (int)*uch_ptr++;
break;
case FLT:
for(i=0; i<n2; i++) *flt_ptr++ = (float)*uch_ptr++;
break;
case DBL:
for(i=0; i<n2; i++) *dbl_ptr++ = (double)*uch_ptr++;
break;
default:
return(-1);
}/*switch*/
break;
case USRT:
usrt_ptr = (unsigned short *)tmp_buf;
switch(in_dt){
case UCH:
for(i=0; i<n2; i++) *uch_ptr++ = (unsigned char)*usrt_ptr++;
break;
case dsINT:
for(i=0; i<n2; i++) *int_ptr++ = (int)*usrt_ptr++;
break;
case FLT:
for(i=0; i<n2; i++) *flt_ptr++ = (float)*usrt_ptr++;
break;
case DBL:
for(i=0; i<n2; i++) *dbl_ptr++ = (double)*usrt_ptr++;
break;
default:
return(-1);
}/*switch*/
break;
case SRT:
srt_ptr = (short *)tmp_buf;
switch(in_dt){
case dsINT:
for(i=0; i<n2; i++) *int_ptr++ = (int)*srt_ptr++;
break;
case FLT:
for(i=0; i<n2; i++) *flt_ptr++ = (float)*srt_ptr++;
break;
default:
return(-1);
}/*switch*/
break;
case FLT:
flt_ptr = (float *)tmp_buf;
switch(in_dt){
case dsINT:
for(i=0; i<n2; i++) *int_ptr++ = (int)*flt_ptr++;
break;
case FLT:
for(i=0; i<n2; i++) *flt_ptr++ = (float)*flt_ptr++;
break;
case DBL:
for(i=0; i<n2; i++) *dbl_ptr++ = (double)*flt_ptr++;
break;
default:
return(-1);
}/*switch*/
break;
case DBL:
dbl_ptr = (double *)tmp_buf;
switch(in_dt){
case dsINT:
for(i=0; i<n2; i++) *int_ptr++ = (int)*dbl_ptr++;
break;
case FLT:
for(i=0; i<n2; i++) *flt_ptr++ = (float)*dbl_ptr++;
break;
default:
return(-1);
}/*switch*/
break;
case SPECIAL_AFLT:
aflt_ptr = (char *)tmp_buf;
switch(in_dt){
case UCH:
for(i=0; i<n2; i++,aflt_ptr+=SPECIAL_ASCII_FLT_SIZE){
dbl_tmp = atof(aflt_ptr) + 0.5;
if( dbl_tmp >= 256.0) dbl_tmp = 255.0;
if( dbl_tmp < 0.0) dbl_tmp = 0.0;
*uch_ptr++ = (unsigned char)floor(dbl_tmp);
}
break;
case USRT:
for(i=0; i<n2; i++,aflt_ptr+=SPECIAL_ASCII_FLT_SIZE){
dbl_tmp = atof(aflt_ptr) + 0.5;
if( dbl_tmp >= 65536.0) dbl_tmp = 65535.0;
if( dbl_tmp < 0.0) dbl_tmp = 0.0;
*usrt_ptr++ = (unsigned short)floor(dbl_tmp);
}
break;
case FLT:
for(i=0; i<n2; i++){
*flt_ptr++ = (float)atof(aflt_ptr);
aflt_ptr += SPECIAL_ASCII_FLT_SIZE;
}
break;
default:
return(-1);
}/*switch*/
break;
default:
return(-1);
}/*switch*/
n1 -= n2;
}/*while*/
/*Free dynamic memory.*/
free(tmp_buf); // SRC_NT BUG!!!!!!!!!!!!!!!!!!!!!!!!!
}/*if*/
else{
n1 = nobj;
tot_num_read = 0;
while( (n2 = MIN(n1,BUFSIZ)) > 0 ){
#ifdef SRC_UNIX
if( (num_read = read(fd,(void*)(in_buf+tot_num_read),(unsigned int)n2*disk_size)) != n2*disk_size)
#endif
#ifdef SRC_NT
if( (num_read = _read(fd,(void*)(in_buf+tot_num_read),(unsigned int)n2*disk_size)) != n2*disk_size)
#endif
if( num_read != 0 ){
return -1;
}
else return 0;
/*SWAP HERE*/
if( swap == YES ){
if( disk_dt == SRT || disk_dt == USRT ){
for(i=0; i<n2; i++){
SWAP( *(in_buf + tot_num_read + i*2),
*(in_buf + tot_num_read + i*2 + 1), tmp_byte);
}
}
}
tot_num_read += num_read;
n1 -= n2;
}/*while*/
}/*else*/
return tot_num_read/disk_size;
}
//--------------|---------------------------------------------
HXRET
hxput(HXFILE * hp, char const *recp, int leng)
{
HXLOCAL loc, *locp = &loc;
if (!hp || leng < 0 || !recp || leng > hxmaxrec(hp)
|| !(hp->mode & HX_UPDATE) || !hp->test)
return HXERR_BAD_REQUEST;
if (leng && !hx_test(hp, recp, leng))
return HXERR_BAD_RECORD;
if (SCANNING(hp) && hx_diff(hp, recp, RECDATA(_hxcurrec(hp))))
return HXERR_BAD_REQUEST;
ENTER(locp, hp, recp, 3);
_hxlockset(locp, leng ? HIGH_LOCK : HEAD_LOCK);
if (IS_MMAP(hp))
_hxremap(locp);
int may_find = 1, loops = HX_MAX_CHAIN;
int newsize = leng ? leng + sizeof(HXREC) : 0;
HXBUF *currp = &locp->buf[0], *prevp = &locp->buf[1];
// If scanning is on an overflow page, and hxdel might
// empty the page, hxput after hxnext can't just jump to
// the right page, because (prevp) is not loaded,
// so deleting currp would hard.
_hxload(locp, currp, SCANNING(hp) && (leng || IS_HEAD(hp->buffer.pgno))
? hp->buffer.pgno : locp->head);
while (1) {
int pos, hindpos, skip = 0;
PAGENO nextpg = currp->next;
if (!--loops)
LEAVE(locp, HXERR_BAD_FILE);
// Search for the key (an old record to be deleted).
// If SCANNING: the file is locked, and the matching
// record must be there.
pos = !may_find ? -1
: !SCANNING(hp) ? _hxfind(locp, currp, locp->hash, recp, &hindpos)
: currp->pgno == hp->buffer.pgno ? hp->currpos : -1;
if (pos >= 0) {
char *oldp = currp->data + pos;
COUNT oldsize = RECSIZE(oldp);
int delta = newsize - oldsize;
locp->ret = RECLENG(oldp);
may_find = 0;
assert(!currp->delta);
currp->delpos = pos;
currp->delta = delta;
if (!newsize) { // hxdel or remove after inserted previously.
_hxremove(currp, pos, oldsize);
currp->recs--;
if (SCANNING(hp))
hp->recsize = 0;
} else if (FITS(hp, currp, delta, 0)) { // replace
if (delta) {
memmove(oldp + newsize, oldp + oldsize,
currp->used - pos - oldsize);
currp->used += delta;
STSH(leng, oldp + sizeof(PAGENO));
if (SCANNING(hp))
hp->recsize = newsize;
DEINDEX(currp); // force indexify
}
memcpy(oldp + sizeof(HXREC), recp, leng);
STAIN(currp);
newsize = 0;
} else if (SCANNING(hp)) {
// At this point we are stuck: if we delete the old copy of
// the record, we are committed to inserting the new copy
// somewhere else, but that might require changing links
// or even growing the file: a NO-NO during a hxnext scan.
LEAVE(locp, HXERR_BAD_REQUEST);
} else { // Delete old version and continue (insert elsewhere).
_hxremove(currp, pos, oldsize);
currp->recs--;
}
}
if (currp->used && !IS_HEAD(currp->pgno) && SHRUNK(prevp))
skip = !_hxshift(locp, locp->head, 0, currp, prevp, NULL);
// Insert the new record if it fits.
if (newsize && FITS(hp, currp, newsize, 1)) {
HXREC hdr;
STLG(locp->hash, &hdr.hash);
STSH(leng, &hdr.leng);
_hxappend(currp, (char *)&hdr, sizeof hdr);
_hxappend(currp, recp, leng);
currp->recs++;
newsize = 0;
}
// If the current page contains only data of OTHER heads
// -- and hence, must be at the END of a chain --
// unlink it from this chain. If the page is empty,
// unlink it AND put it in the freemap.
if (IS_HEAD(currp->pgno)) {
skip = 0;
} else if (!currp->used) {
skip = 1;
_hxputfreed(locp, currp);
if (SCANNING(hp) && hp->buffer.pgno == currp->pgno)
hp->buffer.used = 0;
} else if (currp->next || !SHRUNK(currp)) {
skip = 0;
} else if (!skip) { // If skip not set by _hxshift above...
char const *rp, *ep;
FOR_EACH_REC(rp, currp, ep)
if (locp->head == _hxhead(locp, RECHASH(rp)))
break;
skip = rp == ep; // No recs for locp->head in this tail.
}
if (skip)
LINK(prevp, nextpg);
else
SWAP(prevp, currp);
sync_save(locp, currp);
if (!newsize && !prevp->next)
break;
if (!newsize && !may_find && !SHRUNK(prevp))
break;
if (prevp->next) {
_hxload(locp, currp, prevp->next);
continue;
}
// We are at the end of the chain, and rec not yet inserted.
// Unlocking is necessary even if tail is not shared;
// it may be hp->tail.pgno in some other process.
if (!FILE_HELD(hp) && !IS_HEAD(prevp->pgno))
_hxunlock(locp, prevp->pgno, 1);
// _hxshare/_hxfindfree may update the map (root etc).
// Split MUST be locked before root, else risk deadlock.
_hxlockset(locp, BOTH_LOCK);
if (IS_MMAP(hp))
_hxremap(locp);
// At this point assert:
// - head is locked, split is locked,
// - head matches hash, npages matches filesize.
// After locking the split, no other process can change
// the file size.
may_find = 0;
COUNT need = IS_HEAD(prevp->pgno) ? newsize : 0;
if (!_hxshare(locp, currp, need)
&& !_hxgetfreed(locp, currp)
&& !_hxfindfree(locp, currp)) {
// _hxgrow will zero samehead if it splits locp->head.
PAGENO samehead = locp->head;
// _hxgrow will change the file length. A concurrent
// hxget/hxdel could miscalculate locp->head as
// being the newly-added page.
_hxlock(locp, locp->npages, 0);
_hxgrow(locp, currp, need, &samehead);
DEBUG3("head=%u samehead=%u", locp->head, samehead);
if (!samehead) {
_hxputfreed(locp, currp);
_hxpoint(locp);
_hxload(locp, currp, locp->head);
loops = HX_MAX_CHAIN;
continue;
}
}
// _hxgrow may clobber prevp, so we reload it. Even if
// prevp->pgno == locp->head, prevp may contain an
// obsolete copy of the head page. The empty page is
// always appended to head. _hxshare only returns true
// if currp is head and currp->next is 0, so it can't
// clobber it.
_hxsave(locp, prevp);
_hxload(locp, prevp, locp->head);
LINK(currp, prevp->next);
LINK(prevp, currp->pgno);
currp->orig = DATASIZE(hp); // make SHRUNK be true
}
static void rowswap(Matrix3 &m, int i, int j) {
register Real tmp;
SWAP(m(i,0),m(j,0));
SWAP(m(i,1),m(j,1));
SWAP(m(i,2),m(j,2));
}
int Space2DSW::test_body_ray_separation(Body2DSW *p_body, const Transform2D &p_transform, bool p_infinite_inertia, Vector2 &r_recover_motion, Physics2DServer::SeparationResult *r_results, int p_result_max, real_t p_margin) {
Rect2 body_aabb;
for (int i = 0; i < p_body->get_shape_count(); i++) {
if (i == 0)
body_aabb = p_body->get_shape_aabb(i);
else
body_aabb = body_aabb.merge(p_body->get_shape_aabb(i));
}
// Undo the currently transform the physics server is aware of and apply the provided one
body_aabb = p_transform.xform(p_body->get_inv_transform().xform(body_aabb));
body_aabb = body_aabb.grow(p_margin);
Transform2D body_transform = p_transform;
for (int i = 0; i < p_result_max; i++) {
//reset results
r_results[i].collision_depth = 0;
}
int rays_found = 0;
{
// raycast AND separate
const int max_results = 32;
int recover_attempts = 4;
Vector2 sr[max_results * 2];
Physics2DServerSW::CollCbkData cbk;
cbk.max = max_results;
Physics2DServerSW::CollCbkData *cbkptr = &cbk;
CollisionSolver2DSW::CallbackResult cbkres = Physics2DServerSW::_shape_col_cbk;
do {
Vector2 recover_motion;
bool collided = false;
int amount = _cull_aabb_for_body(p_body, body_aabb);
int ray_index = 0;
for (int j = 0; j < p_body->get_shape_count(); j++) {
if (p_body->is_shape_set_as_disabled(j))
continue;
Shape2DSW *body_shape = p_body->get_shape(j);
if (body_shape->get_type() != Physics2DServer::SHAPE_RAY)
continue;
Transform2D body_shape_xform = body_transform * p_body->get_shape_transform(j);
for (int i = 0; i < amount; i++) {
const CollisionObject2DSW *col_obj = intersection_query_results[i];
int shape_idx = intersection_query_subindex_results[i];
cbk.amount = 0;
cbk.ptr = sr;
cbk.invalid_by_dir = 0;
if (CollisionObject2DSW::TYPE_BODY == col_obj->get_type()) {
const Body2DSW *b = static_cast<const Body2DSW *>(col_obj);
if (p_infinite_inertia && Physics2DServer::BODY_MODE_STATIC != b->get_mode() && Physics2DServer::BODY_MODE_KINEMATIC != b->get_mode()) {
continue;
}
}
if (col_obj->is_shape_set_as_one_way_collision(shape_idx)) {
cbk.valid_dir = body_shape_xform.get_axis(1).normalized();
cbk.valid_depth = p_margin; //only valid depth is the collision margin
cbk.invalid_by_dir = 0;
} else {
cbk.valid_dir = Vector2();
cbk.valid_depth = 0;
cbk.invalid_by_dir = 0;
}
Shape2DSW *against_shape = col_obj->get_shape(shape_idx);
if (CollisionSolver2DSW::solve(body_shape, body_shape_xform, Vector2(), against_shape, col_obj->get_transform() * col_obj->get_shape_transform(shape_idx), Vector2(), cbkres, cbkptr, NULL, p_margin)) {
if (cbk.amount > 0) {
collided = true;
}
if (ray_index < p_result_max) {
Physics2DServer::SeparationResult &result = r_results[ray_index];
for (int k = 0; k < cbk.amount; k++) {
Vector2 a = sr[k * 2 + 0];
Vector2 b = sr[k * 2 + 1];
recover_motion += (b - a) * 0.4;
float depth = a.distance_to(b);
if (depth > result.collision_depth) {
result.collision_depth = depth;
result.collision_point = b;
result.collision_normal = (b - a).normalized();
result.collision_local_shape = shape_idx;
result.collider = col_obj->get_self();
result.collider_id = col_obj->get_instance_id();
result.collider_metadata = col_obj->get_shape_metadata(shape_idx);
if (col_obj->get_type() == CollisionObject2DSW::TYPE_BODY) {
Body2DSW *body = (Body2DSW *)col_obj;
Vector2 rel_vec = b - body->get_transform().get_origin();
result.collider_velocity = Vector2(-body->get_angular_velocity() * rel_vec.y, body->get_angular_velocity() * rel_vec.x) + body->get_linear_velocity();
}
}
}
}
}
}
ray_index++;
}
rays_found = MAX(ray_index, rays_found);
if (!collided || recover_motion == Vector2()) {
break;
}
body_transform.elements[2] += recover_motion;
body_aabb.position += recover_motion;
recover_attempts--;
} while (recover_attempts);
}
//optimize results (remove non colliding)
for (int i = 0; i < rays_found; i++) {
if (r_results[i].collision_depth == 0) {
rays_found--;
SWAP(r_results[i], r_results[rays_found]);
}
}
r_recover_motion = body_transform.elements[2] - p_transform.elements[2];
return rays_found;
}
/*************************************************************************
* This function performs k-way refinement
**************************************************************************/
void Random_KWayEdgeRefineMConn(CtrlType *ctrl, GraphType *graph, int nparts, float *tpwgts, float ubfactor, int npasses, int ffactor)
{
int i, ii, iii, j, jj, k, l, pass, nvtxs, nmoves, nbnd, tvwgt, myndegrees;
int from, me, to, oldcut, vwgt, gain;
int maxndoms, nadd;
idxtype *xadj, *adjncy, *adjwgt;
idxtype *where, *pwgts, *perm, *bndptr, *bndind, *minwgt, *maxwgt, *itpwgts;
idxtype *phtable, *pmat, *pmatptr, *ndoms;
EDegreeType *myedegrees;
RInfoType *myrinfo;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
bndptr = graph->bndptr;
bndind = graph->bndind;
where = graph->where;
pwgts = graph->pwgts;
pmat = ctrl->wspace.pmat;
phtable = idxwspacemalloc(ctrl, nparts);
ndoms = idxwspacemalloc(ctrl, nparts);
ComputeSubDomainGraph(graph, nparts, pmat, ndoms);
/* Setup the weight intervals of the various subdomains */
minwgt = idxwspacemalloc(ctrl, nparts);
maxwgt = idxwspacemalloc(ctrl, nparts);
itpwgts = idxwspacemalloc(ctrl, nparts);
tvwgt = idxsum(nparts, pwgts);
ASSERT(tvwgt == idxsum(nvtxs, graph->vwgt));
for (i=0; i<nparts; i++) {
itpwgts[i] = tpwgts[i]*tvwgt;
maxwgt[i] = tpwgts[i]*tvwgt*ubfactor;
minwgt[i] = tpwgts[i]*tvwgt*(1.0/ubfactor);
}
perm = idxwspacemalloc(ctrl, nvtxs);
IFSET(ctrl->dbglvl, DBG_REFINE,
printf("Partitions: [%6d %6d]-[%6d %6d], Balance: %5.3f, Nv-Nb[%6d %6d]. Cut: %6d\n",
pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)], minwgt[0], maxwgt[0],
1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nvtxs, graph->nbnd,
graph->mincut));
for (pass=0; pass<npasses; pass++) {
ASSERT(ComputeCut(graph, where) == graph->mincut);
maxndoms = ndoms[idxamax(nparts, ndoms)];
oldcut = graph->mincut;
nbnd = graph->nbnd;
RandomPermute(nbnd, perm, 1);
for (nmoves=iii=0; iii<graph->nbnd; iii++) {
ii = perm[iii];
if (ii >= nbnd)
continue;
i = bndind[ii];
myrinfo = graph->rinfo+i;
if (myrinfo->ed >= myrinfo->id) { /* Total ED is too high */
from = where[i];
vwgt = graph->vwgt[i];
if (myrinfo->id > 0 && pwgts[from]-vwgt < minwgt[from])
continue; /* This cannot be moved! */
myedegrees = myrinfo->edegrees;
myndegrees = myrinfo->ndegrees;
/* Determine the valid domains */
for (j=0; j<myndegrees; j++) {
to = myedegrees[j].pid;
phtable[to] = 1;
pmatptr = pmat + to*nparts;
for (nadd=0, k=0; k<myndegrees; k++) {
if (k == j)
continue;
l = myedegrees[k].pid;
if (pmatptr[l] == 0) {
if (ndoms[l] > maxndoms-1) {
phtable[to] = 0;
nadd = maxndoms;
break;
}
nadd++;
}
}
if (ndoms[to]+nadd > maxndoms)
phtable[to] = 0;
if (nadd == 0)
phtable[to] = 2;
}
/* Find the first valid move */
j = myrinfo->id;
for (k=0; k<myndegrees; k++) {
to = myedegrees[k].pid;
if (!phtable[to])
continue;
gain = myedegrees[k].ed-j; /* j = myrinfo->id. Allow good nodes to move */
if (pwgts[to]+vwgt <= maxwgt[to]+ffactor*gain && gain >= 0)
break;
}
if (k == myndegrees)
continue; /* break out if you did not find a candidate */
for (j=k+1; j<myndegrees; j++) {
to = myedegrees[j].pid;
if (!phtable[to])
continue;
if ((myedegrees[j].ed > myedegrees[k].ed && pwgts[to]+vwgt <= maxwgt[to]) ||
(myedegrees[j].ed == myedegrees[k].ed &&
itpwgts[myedegrees[k].pid]*pwgts[to] < itpwgts[to]*pwgts[myedegrees[k].pid]))
k = j;
}
to = myedegrees[k].pid;
j = 0;
if (myedegrees[k].ed-myrinfo->id > 0)
j = 1;
else if (myedegrees[k].ed-myrinfo->id == 0) {
if (/*(iii&7) == 0 ||*/ phtable[myedegrees[k].pid] == 2 || pwgts[from] >= maxwgt[from] || itpwgts[from]*(pwgts[to]+vwgt) < itpwgts[to]*pwgts[from])
j = 1;
}
if (j == 0)
continue;
/*=====================================================================
* If we got here, we can now move the vertex from 'from' to 'to'
*======================================================================*/
graph->mincut -= myedegrees[k].ed-myrinfo->id;
IFSET(ctrl->dbglvl, DBG_MOVEINFO, printf("\t\tMoving %6d to %3d. Gain: %4d. Cut: %6d\n", i, to, myedegrees[k].ed-myrinfo->id, graph->mincut));
/* Update pmat to reflect the move of 'i' */
pmat[from*nparts+to] += (myrinfo->id-myedegrees[k].ed);
pmat[to*nparts+from] += (myrinfo->id-myedegrees[k].ed);
if (pmat[from*nparts+to] == 0) {
ndoms[from]--;
if (ndoms[from]+1 == maxndoms)
maxndoms = ndoms[idxamax(nparts, ndoms)];
}
if (pmat[to*nparts+from] == 0) {
ndoms[to]--;
if (ndoms[to]+1 == maxndoms)
maxndoms = ndoms[idxamax(nparts, ndoms)];
}
/* Update where, weight, and ID/ED information of the vertex you moved */
where[i] = to;
INC_DEC(pwgts[to], pwgts[from], vwgt);
myrinfo->ed += myrinfo->id-myedegrees[k].ed;
SWAP(myrinfo->id, myedegrees[k].ed, j);
if (myedegrees[k].ed == 0)
myedegrees[k] = myedegrees[--myrinfo->ndegrees];
else
myedegrees[k].pid = from;
if (myrinfo->ed-myrinfo->id < 0)
BNDDelete(nbnd, bndind, bndptr, i);
/* Update the degrees of adjacent vertices */
for (j=xadj[i]; j<xadj[i+1]; j++) {
ii = adjncy[j];
me = where[ii];
myrinfo = graph->rinfo+ii;
if (myrinfo->edegrees == NULL) {
myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii];
}
myedegrees = myrinfo->edegrees;
ASSERT(CheckRInfo(myrinfo));
if (me == from) {
INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]);
if (myrinfo->ed-myrinfo->id >= 0 && bndptr[ii] == -1)
BNDInsert(nbnd, bndind, bndptr, ii);
}
else if (me == to) {
INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]);
if (myrinfo->ed-myrinfo->id < 0 && bndptr[ii] != -1)
BNDDelete(nbnd, bndind, bndptr, ii);
}
/* Remove contribution from the .ed of 'from' */
if (me != from) {
for (k=0; k<myrinfo->ndegrees; k++) {
if (myedegrees[k].pid == from) {
if (myedegrees[k].ed == adjwgt[j])
myedegrees[k] = myedegrees[--myrinfo->ndegrees];
else
myedegrees[k].ed -= adjwgt[j];
break;
}
}
}
/* Add contribution to the .ed of 'to' */
if (me != to) {
for (k=0; k<myrinfo->ndegrees; k++) {
if (myedegrees[k].pid == to) {
myedegrees[k].ed += adjwgt[j];
break;
}
}
if (k == myrinfo->ndegrees) {
myedegrees[myrinfo->ndegrees].pid = to;
myedegrees[myrinfo->ndegrees++].ed = adjwgt[j];
}
}
/* Update pmat to reflect the move of 'i' for domains other than 'from' and 'to' */
if (me != from && me != to) {
pmat[me*nparts+from] -= adjwgt[j];
pmat[from*nparts+me] -= adjwgt[j];
if (pmat[me*nparts+from] == 0) {
ndoms[me]--;
if (ndoms[me]+1 == maxndoms)
maxndoms = ndoms[idxamax(nparts, ndoms)];
}
if (pmat[from*nparts+me] == 0) {
ndoms[from]--;
if (ndoms[from]+1 == maxndoms)
maxndoms = ndoms[idxamax(nparts, ndoms)];
}
if (pmat[me*nparts+to] == 0) {
ndoms[me]++;
if (ndoms[me] > maxndoms) {
printf("You just increased the maxndoms: %d %d\n", ndoms[me], maxndoms);
maxndoms = ndoms[me];
}
}
if (pmat[to*nparts+me] == 0) {
ndoms[to]++;
if (ndoms[to] > maxndoms) {
printf("You just increased the maxndoms: %d %d\n", ndoms[to], maxndoms);
maxndoms = ndoms[to];
}
}
pmat[me*nparts+to] += adjwgt[j];
pmat[to*nparts+me] += adjwgt[j];
}
ASSERT(myrinfo->ndegrees <= xadj[ii+1]-xadj[ii]);
ASSERT(CheckRInfo(myrinfo));
}
nmoves++;
}
}
graph->nbnd = nbnd;
IFSET(ctrl->dbglvl, DBG_REFINE,
printf("\t[%6d %6d], Balance: %5.3f, Nb: %6d. Nmoves: %5d, Cut: %5d, Vol: %5d, %d\n",
pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)],
1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nbnd, nmoves,
graph->mincut, ComputeVolume(graph, where), idxsum(nparts, ndoms)));
if (graph->mincut == oldcut)
break;
}
idxwspacefree(ctrl, nparts);
idxwspacefree(ctrl, nparts);
idxwspacefree(ctrl, nparts);
idxwspacefree(ctrl, nparts);
idxwspacefree(ctrl, nparts);
idxwspacefree(ctrl, nvtxs);
}
int gaussj(FTYPE **a, int n, FTYPE **b, int m)
{
int *indxc, *indxr, *ipiv;
int i, icol, irow, j, k, l, ll;
FTYPE big, dum, pivinv, temp;
indxc = ivector(1, n);
indxr = ivector(1, n);
ipiv = ivector(1, n);
for (j = 1; j <= n; j++)
ipiv[j] = 0;
for (i = 1; i <= n; i++) {
big = 0.0;
for (j = 1; j <= n; j++)
if (ipiv[j] != 1)
for (k = 1; k <= n; k++) {
if (ipiv[k] == 0) {
if (fabs(a[j][k]) >= big) {
big = fabs(a[j][k]);
irow = j;
icol = k;
}// assume no other conditions GODMARK (compiler warning)
} else if (ipiv[k] > 1) {
dualfprintf(fail_file, "choke in gaussj\n");
myexit(2);
}
}
++(ipiv[icol]);
if (irow != icol) {
for (l = 1; l <= n; l++) {
SWAP(a[irow][l], a[icol][l])}
for (l = 1; l <= m; l++) {
SWAP(b[irow][l], b[icol][l])}
}
indxr[i] = irow;
indxc[i] = icol;
if (a[icol][icol] == 0.0) {
if(debugfail>=2) dualfprintf(fail_file, "gaussj: Singular Matrix-2\n");
return(1);
}
pivinv = 1.0 / a[icol][icol];
a[icol][icol] = 1.0;
for (l = 1; l <= n; l++)
a[icol][l] *= pivinv;
for (l = 1; l <= m; l++)
b[icol][l] *= pivinv;
for (ll = 1; ll <= n; ll++)
if (ll != icol) {
dum = a[ll][icol];
a[ll][icol] = 0.0;
for (l = 1; l <= n; l++)
a[ll][l] -= a[icol][l] * dum;
for (l = 1; l <= m; l++)
b[ll][l] -= b[icol][l] * dum;
}
}
for (l = n; l >= 1; l--) {
if (indxr[l] != indxc[l])
for (k = 1; k <= n; k++)
SWAP(a[k][indxr[l]], a[k][indxc[l]]);
}
free_ivector(ipiv, 1, n);
free_ivector(indxr, 1, n);
free_ivector(indxc, 1, n);
return(0);
}
/*************************************************************************
* This function performs k-way refinement
**************************************************************************/
void Greedy_KWayEdgeBalanceMConn(CtrlType *ctrl, GraphType *graph, int nparts, float *tpwgts, float ubfactor, int npasses)
{
int i, ii, iii, j, jj, k, l, pass, nvtxs, nbnd, tvwgt, myndegrees, oldgain, gain, nmoves;
int from, me, to, oldcut, vwgt, maxndoms, nadd;
idxtype *xadj, *adjncy, *adjwgt;
idxtype *where, *pwgts, *perm, *bndptr, *bndind, *minwgt, *maxwgt, *moved, *itpwgts;
idxtype *phtable, *pmat, *pmatptr, *ndoms;
EDegreeType *myedegrees;
RInfoType *myrinfo;
PQueueType queue;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
bndind = graph->bndind;
bndptr = graph->bndptr;
where = graph->where;
pwgts = graph->pwgts;
pmat = ctrl->wspace.pmat;
phtable = idxwspacemalloc(ctrl, nparts);
ndoms = idxwspacemalloc(ctrl, nparts);
ComputeSubDomainGraph(graph, nparts, pmat, ndoms);
/* Setup the weight intervals of the various subdomains */
minwgt = idxwspacemalloc(ctrl, nparts);
maxwgt = idxwspacemalloc(ctrl, nparts);
itpwgts = idxwspacemalloc(ctrl, nparts);
tvwgt = idxsum(nparts, pwgts);
ASSERT(tvwgt == idxsum(nvtxs, graph->vwgt));
for (i=0; i<nparts; i++) {
itpwgts[i] = tpwgts[i]*tvwgt;
maxwgt[i] = tpwgts[i]*tvwgt*ubfactor;
minwgt[i] = tpwgts[i]*tvwgt*(1.0/ubfactor);
}
perm = idxwspacemalloc(ctrl, nvtxs);
moved = idxwspacemalloc(ctrl, nvtxs);
PQueueInit(ctrl, &queue, nvtxs, graph->adjwgtsum[idxamax(nvtxs, graph->adjwgtsum)]);
IFSET(ctrl->dbglvl, DBG_REFINE,
printf("Partitions: [%6d %6d]-[%6d %6d], Balance: %5.3f, Nv-Nb[%6d %6d]. Cut: %6d [B]\n",
pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)], minwgt[0], maxwgt[0],
1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nvtxs, graph->nbnd,
graph->mincut));
for (pass=0; pass<npasses; pass++) {
ASSERT(ComputeCut(graph, where) == graph->mincut);
/* Check to see if things are out of balance, given the tolerance */
for (i=0; i<nparts; i++) {
if (pwgts[i] > maxwgt[i])
break;
}
if (i == nparts) /* Things are balanced. Return right away */
break;
PQueueReset(&queue);
idxset(nvtxs, -1, moved);
oldcut = graph->mincut;
nbnd = graph->nbnd;
RandomPermute(nbnd, perm, 1);
for (ii=0; ii<nbnd; ii++) {
i = bndind[perm[ii]];
PQueueInsert(&queue, i, graph->rinfo[i].ed - graph->rinfo[i].id);
moved[i] = 2;
}
maxndoms = ndoms[idxamax(nparts, ndoms)];
for (nmoves=0;;) {
if ((i = PQueueGetMax(&queue)) == -1)
break;
moved[i] = 1;
myrinfo = graph->rinfo+i;
from = where[i];
vwgt = graph->vwgt[i];
if (pwgts[from]-vwgt < minwgt[from])
continue; /* This cannot be moved! */
myedegrees = myrinfo->edegrees;
myndegrees = myrinfo->ndegrees;
/* Determine the valid domains */
for (j=0; j<myndegrees; j++) {
to = myedegrees[j].pid;
phtable[to] = 1;
pmatptr = pmat + to*nparts;
for (nadd=0, k=0; k<myndegrees; k++) {
if (k == j)
continue;
l = myedegrees[k].pid;
if (pmatptr[l] == 0) {
if (ndoms[l] > maxndoms-1) {
phtable[to] = 0;
nadd = maxndoms;
break;
}
nadd++;
}
}
if (ndoms[to]+nadd > maxndoms)
phtable[to] = 0;
}
for (k=0; k<myndegrees; k++) {
to = myedegrees[k].pid;
if (!phtable[to])
continue;
if (pwgts[to]+vwgt <= maxwgt[to] || itpwgts[from]*(pwgts[to]+vwgt) <= itpwgts[to]*pwgts[from])
break;
}
if (k == myndegrees)
continue; /* break out if you did not find a candidate */
for (j=k+1; j<myndegrees; j++) {
to = myedegrees[j].pid;
if (!phtable[to])
continue;
if (itpwgts[myedegrees[k].pid]*pwgts[to] < itpwgts[to]*pwgts[myedegrees[k].pid])
k = j;
}
to = myedegrees[k].pid;
if (pwgts[from] < maxwgt[from] && pwgts[to] > minwgt[to] && myedegrees[k].ed-myrinfo->id < 0)
continue;
/*=====================================================================
* If we got here, we can now move the vertex from 'from' to 'to'
*======================================================================*/
graph->mincut -= myedegrees[k].ed-myrinfo->id;
IFSET(ctrl->dbglvl, DBG_MOVEINFO, printf("\t\tMoving %6d to %3d. Gain: %4d. Cut: %6d\n", i, to, myedegrees[k].ed-myrinfo->id, graph->mincut));
/* Update pmat to reflect the move of 'i' */
pmat[from*nparts+to] += (myrinfo->id-myedegrees[k].ed);
pmat[to*nparts+from] += (myrinfo->id-myedegrees[k].ed);
if (pmat[from*nparts+to] == 0) {
ndoms[from]--;
if (ndoms[from]+1 == maxndoms)
maxndoms = ndoms[idxamax(nparts, ndoms)];
}
if (pmat[to*nparts+from] == 0) {
ndoms[to]--;
if (ndoms[to]+1 == maxndoms)
maxndoms = ndoms[idxamax(nparts, ndoms)];
}
/* Update where, weight, and ID/ED information of the vertex you moved */
where[i] = to;
INC_DEC(pwgts[to], pwgts[from], vwgt);
myrinfo->ed += myrinfo->id-myedegrees[k].ed;
SWAP(myrinfo->id, myedegrees[k].ed, j);
if (myedegrees[k].ed == 0)
myedegrees[k] = myedegrees[--myrinfo->ndegrees];
else
myedegrees[k].pid = from;
if (myrinfo->ed == 0)
BNDDelete(nbnd, bndind, bndptr, i);
/* Update the degrees of adjacent vertices */
for (j=xadj[i]; j<xadj[i+1]; j++) {
ii = adjncy[j];
me = where[ii];
myrinfo = graph->rinfo+ii;
if (myrinfo->edegrees == NULL) {
myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii];
}
myedegrees = myrinfo->edegrees;
ASSERT(CheckRInfo(myrinfo));
oldgain = (myrinfo->ed-myrinfo->id);
if (me == from) {
INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]);
if (myrinfo->ed > 0 && bndptr[ii] == -1)
BNDInsert(nbnd, bndind, bndptr, ii);
}
else if (me == to) {
INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]);
if (myrinfo->ed == 0 && bndptr[ii] != -1)
BNDDelete(nbnd, bndind, bndptr, ii);
}
/* Remove contribution from the .ed of 'from' */
if (me != from) {
for (k=0; k<myrinfo->ndegrees; k++) {
if (myedegrees[k].pid == from) {
if (myedegrees[k].ed == adjwgt[j])
myedegrees[k] = myedegrees[--myrinfo->ndegrees];
else
myedegrees[k].ed -= adjwgt[j];
break;
}
}
}
/* Add contribution to the .ed of 'to' */
if (me != to) {
for (k=0; k<myrinfo->ndegrees; k++) {
if (myedegrees[k].pid == to) {
myedegrees[k].ed += adjwgt[j];
break;
}
}
if (k == myrinfo->ndegrees) {
myedegrees[myrinfo->ndegrees].pid = to;
myedegrees[myrinfo->ndegrees++].ed = adjwgt[j];
}
}
/* Update pmat to reflect the move of 'i' for domains other than 'from' and 'to' */
if (me != from && me != to) {
pmat[me*nparts+from] -= adjwgt[j];
pmat[from*nparts+me] -= adjwgt[j];
if (pmat[me*nparts+from] == 0) {
ndoms[me]--;
if (ndoms[me]+1 == maxndoms)
maxndoms = ndoms[idxamax(nparts, ndoms)];
}
if (pmat[from*nparts+me] == 0) {
ndoms[from]--;
if (ndoms[from]+1 == maxndoms)
maxndoms = ndoms[idxamax(nparts, ndoms)];
}
if (pmat[me*nparts+to] == 0) {
ndoms[me]++;
if (ndoms[me] > maxndoms) {
printf("You just increased the maxndoms: %d %d\n", ndoms[me], maxndoms);
maxndoms = ndoms[me];
}
}
if (pmat[to*nparts+me] == 0) {
ndoms[to]++;
if (ndoms[to] > maxndoms) {
printf("You just increased the maxndoms: %d %d\n", ndoms[to], maxndoms);
maxndoms = ndoms[to];
}
}
pmat[me*nparts+to] += adjwgt[j];
pmat[to*nparts+me] += adjwgt[j];
}
/* Update the queue */
if (me == to || me == from) {
gain = myrinfo->ed-myrinfo->id;
if (moved[ii] == 2) {
if (myrinfo->ed > 0)
PQueueUpdate(&queue, ii, oldgain, gain);
else {
PQueueDelete(&queue, ii, oldgain);
moved[ii] = -1;
}
}
else if (moved[ii] == -1 && myrinfo->ed > 0) {
PQueueInsert(&queue, ii, gain);
moved[ii] = 2;
}
}
ASSERT(myrinfo->ndegrees <= xadj[ii+1]-xadj[ii]);
ASSERT(CheckRInfo(myrinfo));
}
nmoves++;
}
graph->nbnd = nbnd;
IFSET(ctrl->dbglvl, DBG_REFINE,
printf("\t[%6d %6d], Balance: %5.3f, Nb: %6d. Nmoves: %5d, Cut: %6d, %d\n",
pwgts[idxamin(nparts, pwgts)], pwgts[idxamax(nparts, pwgts)],
1.0*nparts*pwgts[idxamax(nparts, pwgts)]/tvwgt, graph->nbnd, nmoves, graph->mincut,idxsum(nparts, ndoms)));
}
PQueueFree(ctrl, &queue);
idxwspacefree(ctrl, nparts);
idxwspacefree(ctrl, nparts);
idxwspacefree(ctrl, nparts);
idxwspacefree(ctrl, nparts);
idxwspacefree(ctrl, nparts);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
}
static void ssort1(char ** x, int n, int depth, int * oi)
{
int a,b,c,d,r,v;
if (n <= 1) return;
a = rand() % n;
SWAP(x[0], x[a]);
if (oi)
SWAP(oi[0], oi[a]);
v = x[0][depth];
a = b = 1;
c = d = n-1;
while (1)
{
while (b <= c && (r = x[b][depth]-v) <= 0)
{
if (r == 0)
{
SWAP(x[a], x[b]);
if (oi)
SWAP(oi[a], oi[b]);
++a;
}
++b;
}
while (b <= c && (r = x[c][depth]-v) >= 0)
{
if (r == 0)
{
SWAP(x[c], x[d]);
if (oi)
SWAP(oi[c], oi[d]);
--d;
}
--c;
}
if (b > c) break;
SWAP(x[b], x[c]);
if (oi)
SWAP(oi[b], oi[c]);
++b; --c;
}
r = MIN(a,b-a); vecswap(0,b-r,r,x,oi);
r = MIN(d-c,n-d-1); vecswap(b,n-r,r,x,oi);
r = b-a; ssort1(x,r,depth,oi);
if (x[r][depth] != 0)
{
if (oi)
ssort1 (x + r, a + n - d - 1, depth + 1, oi + r);
else
ssort1 (x + r, a + n - d - 1, depth + 1, NULL);
}
r = d - c;
if (oi)
ssort1(x+n-r,r,depth,oi+n-r);
else
ssort1(x+n-r,r,depth,NULL);
}
/*************************************************************************
* This function moves a collection of vertices and updates their rinfo
**************************************************************************/
void MoveGroupMConn(CtrlType *ctrl, GraphType *graph, idxtype *ndoms, idxtype *pmat,
int nparts, int to, int nind, idxtype *ind)
{
int i, ii, iii, j, jj, k, l, nvtxs, nbnd, myndegrees;
int from, me;
idxtype *xadj, *adjncy, *adjwgt;
idxtype *where, *bndptr, *bndind;
EDegreeType *myedegrees;
RInfoType *myrinfo;
nvtxs = graph->nvtxs;
xadj = graph->xadj;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
where = graph->where;
bndptr = graph->bndptr;
bndind = graph->bndind;
nbnd = graph->nbnd;
for (iii=0; iii<nind; iii++) {
i = ind[iii];
from = where[i];
myrinfo = graph->rinfo+i;
if (myrinfo->edegrees == NULL) {
myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
ctrl->wspace.cdegree += xadj[i+1]-xadj[i];
myrinfo->ndegrees = 0;
}
myedegrees = myrinfo->edegrees;
/* find the location of 'to' in myrinfo or create it if it is not there */
for (k=0; k<myrinfo->ndegrees; k++) {
if (myedegrees[k].pid == to)
break;
}
if (k == myrinfo->ndegrees) {
myedegrees[k].pid = to;
myedegrees[k].ed = 0;
myrinfo->ndegrees++;
}
graph->mincut -= myedegrees[k].ed-myrinfo->id;
/* Update pmat to reflect the move of 'i' */
pmat[from*nparts+to] += (myrinfo->id-myedegrees[k].ed);
pmat[to*nparts+from] += (myrinfo->id-myedegrees[k].ed);
if (pmat[from*nparts+to] == 0)
ndoms[from]--;
if (pmat[to*nparts+from] == 0)
ndoms[to]--;
/* Update where, weight, and ID/ED information of the vertex you moved */
where[i] = to;
myrinfo->ed += myrinfo->id-myedegrees[k].ed;
SWAP(myrinfo->id, myedegrees[k].ed, j);
if (myedegrees[k].ed == 0)
myedegrees[k] = myedegrees[--myrinfo->ndegrees];
else
myedegrees[k].pid = from;
if (myrinfo->ed-myrinfo->id < 0 && bndptr[i] != -1)
BNDDelete(nbnd, bndind, bndptr, i);
/* Update the degrees of adjacent vertices */
for (j=xadj[i]; j<xadj[i+1]; j++) {
ii = adjncy[j];
me = where[ii];
myrinfo = graph->rinfo+ii;
if (myrinfo->edegrees == NULL) {
myrinfo->edegrees = ctrl->wspace.edegrees+ctrl->wspace.cdegree;
ctrl->wspace.cdegree += xadj[ii+1]-xadj[ii];
}
myedegrees = myrinfo->edegrees;
ASSERT(CheckRInfo(myrinfo));
if (me == from) {
INC_DEC(myrinfo->ed, myrinfo->id, adjwgt[j]);
if (myrinfo->ed-myrinfo->id >= 0 && bndptr[ii] == -1)
BNDInsert(nbnd, bndind, bndptr, ii);
}
else if (me == to) {
INC_DEC(myrinfo->id, myrinfo->ed, adjwgt[j]);
if (myrinfo->ed-myrinfo->id < 0 && bndptr[ii] != -1)
BNDDelete(nbnd, bndind, bndptr, ii);
}
/* Remove contribution from the .ed of 'from' */
if (me != from) {
for (k=0; k<myrinfo->ndegrees; k++) {
if (myedegrees[k].pid == from) {
if (myedegrees[k].ed == adjwgt[j])
myedegrees[k] = myedegrees[--myrinfo->ndegrees];
else
myedegrees[k].ed -= adjwgt[j];
break;
}
}
}
/* Add contribution to the .ed of 'to' */
if (me != to) {
for (k=0; k<myrinfo->ndegrees; k++) {
if (myedegrees[k].pid == to) {
myedegrees[k].ed += adjwgt[j];
break;
}
}
if (k == myrinfo->ndegrees) {
myedegrees[myrinfo->ndegrees].pid = to;
myedegrees[myrinfo->ndegrees++].ed = adjwgt[j];
}
}
/* Update pmat to reflect the move of 'i' for domains other than 'from' and 'to' */
if (me != from && me != to) {
pmat[me*nparts+from] -= adjwgt[j];
pmat[from*nparts+me] -= adjwgt[j];
if (pmat[me*nparts+from] == 0)
ndoms[me]--;
if (pmat[from*nparts+me] == 0)
ndoms[from]--;
if (pmat[me*nparts+to] == 0)
ndoms[me]++;
if (pmat[to*nparts+me] == 0)
ndoms[to]++;
pmat[me*nparts+to] += adjwgt[j];
pmat[to*nparts+me] += adjwgt[j];
}
ASSERT(CheckRInfo(myrinfo));
}
ASSERT(CheckRInfo(graph->rinfo+i));
}
graph->nbnd = nbnd;
}
static PetscErrorCode KSPSolve_LSQR(KSP ksp)
{
PetscErrorCode ierr;
PetscInt i,size1,size2;
PetscScalar rho,rhobar,phi,phibar,theta,c,s,tmp,tau;
PetscReal beta,alpha,rnorm;
Vec X,B,V,V1,U,U1,TMP,W,W2,SE,Z = NULL;
Mat Amat,Pmat;
MatStructure pflag;
KSP_LSQR *lsqr = (KSP_LSQR*)ksp->data;
PetscBool diagonalscale,nopreconditioner;
PetscFunctionBegin;
ierr = PCGetDiagonalScale(ksp->pc,&diagonalscale);CHKERRQ(ierr);
if (diagonalscale) SETERRQ1(PetscObjectComm((PetscObject)ksp),PETSC_ERR_SUP,"Krylov method %s does not support diagonal scaling",((PetscObject)ksp)->type_name);
ierr = PCGetOperators(ksp->pc,&Amat,&Pmat,&pflag);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject)ksp->pc,PCNONE,&nopreconditioner);CHKERRQ(ierr);
/* nopreconditioner =PETSC_FALSE; */
/* Calculate norm of right hand side */
ierr = VecNorm(ksp->vec_rhs,NORM_2,&lsqr->rhs_norm);CHKERRQ(ierr);
/* mark norm of matrix with negative number to indicate it has not yet been computed */
lsqr->anorm = -1.0;
/* vectors of length m, where system size is mxn */
B = ksp->vec_rhs;
U = lsqr->vwork_m[0];
U1 = lsqr->vwork_m[1];
/* vectors of length n */
X = ksp->vec_sol;
W = lsqr->vwork_n[0];
V = lsqr->vwork_n[1];
V1 = lsqr->vwork_n[2];
W2 = lsqr->vwork_n[3];
if (!nopreconditioner) Z = lsqr->vwork_n[4];
/* standard error vector */
SE = lsqr->se;
if (SE) {
ierr = VecGetSize(SE,&size1);CHKERRQ(ierr);
ierr = VecGetSize(X,&size2);CHKERRQ(ierr);
if (size1 != size2) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_ARG_SIZ,"Standard error vector (size %d) does not match solution vector (size %d)",size1,size2);
ierr = VecSet(SE,0.0);CHKERRQ(ierr);
}
/* Compute initial residual, temporarily use work vector u */
if (!ksp->guess_zero) {
ierr = KSP_MatMult(ksp,Amat,X,U);CHKERRQ(ierr); /* u <- b - Ax */
ierr = VecAYPX(U,-1.0,B);CHKERRQ(ierr);
} else {
ierr = VecCopy(B,U);CHKERRQ(ierr); /* u <- b (x is 0) */
}
/* Test for nothing to do */
ierr = VecNorm(U,NORM_2,&rnorm);CHKERRQ(ierr);
ierr = PetscObjectSAWsTakeAccess((PetscObject)ksp);CHKERRQ(ierr);
ksp->its = 0;
ksp->rnorm = rnorm;
ierr = PetscObjectSAWsGrantAccess((PetscObject)ksp);CHKERRQ(ierr);
ierr = KSPLogResidualHistory(ksp,rnorm);CHKERRQ(ierr);
ierr = KSPMonitor(ksp,0,rnorm);CHKERRQ(ierr);
ierr = (*ksp->converged)(ksp,0,rnorm,&ksp->reason,ksp->cnvP);CHKERRQ(ierr);
if (ksp->reason) PetscFunctionReturn(0);
beta = rnorm;
ierr = VecScale(U,1.0/beta);CHKERRQ(ierr);
ierr = KSP_MatMultTranspose(ksp,Amat,U,V);CHKERRQ(ierr);
if (nopreconditioner) {
ierr = VecNorm(V,NORM_2,&alpha);CHKERRQ(ierr);
} else {
ierr = PCApply(ksp->pc,V,Z);CHKERRQ(ierr);
ierr = VecDotRealPart(V,Z,&alpha);CHKERRQ(ierr);
if (alpha <= 0.0) {
ksp->reason = KSP_DIVERGED_BREAKDOWN;
PetscFunctionReturn(0);
}
alpha = PetscSqrtReal(alpha);
ierr = VecScale(Z,1.0/alpha);CHKERRQ(ierr);
}
ierr = VecScale(V,1.0/alpha);CHKERRQ(ierr);
if (nopreconditioner) {
ierr = VecCopy(V,W);CHKERRQ(ierr);
} else {
ierr = VecCopy(Z,W);CHKERRQ(ierr);
}
lsqr->arnorm = alpha * beta;
phibar = beta;
rhobar = alpha;
i = 0;
do {
if (nopreconditioner) {
ierr = KSP_MatMult(ksp,Amat,V,U1);CHKERRQ(ierr);
} else {
ierr = KSP_MatMult(ksp,Amat,Z,U1);CHKERRQ(ierr);
}
ierr = VecAXPY(U1,-alpha,U);CHKERRQ(ierr);
ierr = VecNorm(U1,NORM_2,&beta);CHKERRQ(ierr);
if (beta == 0.0) {
ksp->reason = KSP_DIVERGED_BREAKDOWN;
break;
}
ierr = VecScale(U1,1.0/beta);CHKERRQ(ierr);
ierr = KSP_MatMultTranspose(ksp,Amat,U1,V1);CHKERRQ(ierr);
ierr = VecAXPY(V1,-beta,V);CHKERRQ(ierr);
if (nopreconditioner) {
ierr = VecNorm(V1,NORM_2,&alpha);CHKERRQ(ierr);
} else {
ierr = PCApply(ksp->pc,V1,Z);CHKERRQ(ierr);
ierr = VecDotRealPart(V1,Z,&alpha);CHKERRQ(ierr);
if (alpha <= 0.0) {
ksp->reason = KSP_DIVERGED_BREAKDOWN;
break;
}
alpha = PetscSqrtReal(alpha);
ierr = VecScale(Z,1.0/alpha);CHKERRQ(ierr);
}
ierr = VecScale(V1,1.0/alpha);CHKERRQ(ierr);
rho = PetscSqrtScalar(rhobar*rhobar + beta*beta);
c = rhobar / rho;
s = beta / rho;
theta = s * alpha;
rhobar = -c * alpha;
phi = c * phibar;
phibar = s * phibar;
tau = s * phi;
ierr = VecAXPY(X,phi/rho,W);CHKERRQ(ierr); /* x <- x + (phi/rho) w */
if (SE) {
ierr = VecCopy(W,W2);CHKERRQ(ierr);
ierr = VecSquare(W2);CHKERRQ(ierr);
ierr = VecScale(W2,1.0/(rho*rho));CHKERRQ(ierr);
ierr = VecAXPY(SE, 1.0, W2);CHKERRQ(ierr); /* SE <- SE + (w^2/rho^2) */
}
if (nopreconditioner) {
ierr = VecAYPX(W,-theta/rho,V1);CHKERRQ(ierr); /* w <- v - (theta/rho) w */
} else {
ierr = VecAYPX(W,-theta/rho,Z);CHKERRQ(ierr); /* w <- z - (theta/rho) w */
}
lsqr->arnorm = alpha*PetscAbsScalar(tau);
rnorm = PetscRealPart(phibar);
ierr = PetscObjectSAWsTakeAccess((PetscObject)ksp);CHKERRQ(ierr);
ksp->its++;
ksp->rnorm = rnorm;
ierr = PetscObjectSAWsGrantAccess((PetscObject)ksp);CHKERRQ(ierr);
ierr = KSPLogResidualHistory(ksp,rnorm);CHKERRQ(ierr);
ierr = KSPMonitor(ksp,i+1,rnorm);CHKERRQ(ierr);
ierr = (*ksp->converged)(ksp,i+1,rnorm,&ksp->reason,ksp->cnvP);CHKERRQ(ierr);
if (ksp->reason) break;
SWAP(U1,U,TMP);
SWAP(V1,V,TMP);
i++;
} while (i<ksp->max_it);
if (i >= ksp->max_it && !ksp->reason) ksp->reason = KSP_DIVERGED_ITS;
/* Finish off the standard error estimates */
if (SE) {
tmp = 1.0;
ierr = MatGetSize(Amat,&size1,&size2);CHKERRQ(ierr);
if (size1 > size2) tmp = size1 - size2;
tmp = rnorm / PetscSqrtScalar(tmp);
ierr = VecSqrtAbs(SE);CHKERRQ(ierr);
ierr = VecScale(SE,tmp);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
void Basis::transpose() {
SWAP(elements[0][1], elements[1][0]);
SWAP(elements[0][2], elements[2][0]);
SWAP(elements[1][2], elements[2][1]);
}
void AudioServer::_mix_step() {
for (int i = 0; i < buses.size(); i++) {
Bus *bus = buses[i];
bus->index_cache = i; //might be moved around by editor, so..
for (int k = 0; k < bus->channels.size(); k++) {
bus->channels[k].used = false;
}
}
//make callbacks for mixing the audio
for (Set<CallbackItem>::Element *E = callbacks.front(); E; E = E->next()) {
E->get().callback(E->get().userdata);
}
for (int i = buses.size() - 1; i >= 0; i--) {
//go bus by bus
Bus *bus = buses[i];
for (int k = 0; k < bus->channels.size(); k++) {
if (bus->channels[k].active && !bus->channels[k].used) {
//buffer was not used, but it's still active, so it must be cleaned
AudioFrame *buf = bus->channels[k].buffer.ptr();
for (uint32_t j = 0; j < buffer_size; j++) {
buf[j] = AudioFrame(0, 0);
}
}
}
//process effects
for (int j = 0; j < bus->effects.size(); j++) {
if (!bus->effects[j].enabled)
continue;
for (int k = 0; k < bus->channels.size(); k++) {
if (!bus->channels[k].active)
continue;
bus->channels[k].effect_instances[j]->process(bus->channels[k].buffer.ptr(), temp_buffer[k].ptr(), buffer_size);
}
//swap buffers, so internal buffer always has the right data
for (int k = 0; k < bus->channels.size(); k++) {
if (!buses[i]->channels[k].active)
continue;
SWAP(bus->channels[k].buffer, temp_buffer[k]);
}
}
//process send
Bus *send = NULL;
if (i > 0) {
//everything has a send save for master bus
if (!bus_map.has(bus->send)) {
send = buses[0];
} else {
send = bus_map[bus->send];
if (send->index_cache >= bus->index_cache) { //invalid, send to master
send = buses[0];
}
}
}
for (int k = 0; k < bus->channels.size(); k++) {
if (!bus->channels[k].active)
continue;
AudioFrame *buf = bus->channels[k].buffer.ptr();
AudioFrame peak = AudioFrame(0, 0);
for (uint32_t j = 0; j < buffer_size; j++) {
float l = ABS(buf[j].l);
if (l > peak.l) {
peak.l = l;
}
float r = ABS(buf[j].r);
if (r > peak.r) {
peak.r = r;
}
}
bus->channels[k].peak_volume = AudioFrame(Math::linear2db(peak.l + 0.0000000001), Math::linear2db(peak.r + 0.0000000001));
if (!bus->channels[k].used) {
//see if any audio is contained, because channel was not used
if (MAX(peak.r, peak.l) > Math::db2linear(channel_disable_treshold_db)) {
bus->channels[k].last_mix_with_audio = mix_frames;
} else if (mix_frames - bus->channels[k].last_mix_with_audio > channel_disable_frames) {
bus->channels[k].active = false;
continue; //went inactive, don't mix.
}
}
if (send) {
//if not master bus, send
AudioFrame *target_buf = thread_get_channel_mix_buffer(send->index_cache, k);
for (uint32_t j = 0; j < buffer_size; j++) {
target_buf[j] += buf[j];
}
}
}
}
mix_frames += buffer_size;
to_mix = buffer_size;
}
static void fft_1d(double *data, int nn, int isign)
{
int n, mmax, m, j, istep, i;
double wtemp, wr, wi, wpr, wpi, theta, tempr, tempi;
/* Fix indexing problems (see above) */
data = data - 1;
/* Bit reversal section */
n = nn << 1;
j = 1;
for (i = 1; i < n; i += 2)
{
if (j > i)
{
SWAP(data[j], data[i]);
SWAP(data[j + 1], data[i + 1]);
}
m = n >> 1;
while (m >= 2 && j > m)
{
j -= m;
m = m >> 1;
}
j += m;
}
/* Danielson-Lanczos section */
mmax = 2;
while (n > mmax)
{
istep = 2 * mmax;
theta = TWOPI / (isign * mmax);
wtemp = sin(0.5 * theta);
wpr = -2.0 * wtemp * wtemp;
wpi = sin(theta);
wr = 1.0;
wi = 0.0;
for (m = 1; m < mmax; m += 2)
{
for (i = m; i <= n; i += istep)
{
j = i + mmax;
tempr = (double)(wr * data[j] - wi * data[j + 1]);
tempi = (double)(wr * data[j + 1] + wi * data[j]);
data[j] = data[i] - tempr;
data[j + 1] = data[i + 1] - tempi;
data[i] += tempr;
data[i + 1] += tempi;
}
wtemp = wr;
wr += wr * wpr - wi * wpi;
wi += wi * wpr + wtemp * wpi;
}
mmax = istep;
}
/* Normalizing section */
if (isign == 1)
{
n = nn << 1;
for (i = 1; i <= n; i++)
data[i] = data[i] / nn;
}
}
/*************************************************************************
* This function performs an edge-based FM refinement
**************************************************************************/
void MocGeneral2WayBalance(CtrlType *ctrl, GraphType *graph, float *tpwgts, float lbfactor)
{
int i, ii, j, k, l, kwgt, nvtxs, ncon, nbnd, nswaps, from, to, limit, tmp, cnum;
idxtype *xadj, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind;
idxtype *moved, *swaps, *perm, *qnum;
float *nvwgt, *npwgts, mindiff[MAXNCON], origbal, minbal, newbal;
PQueueType parts[MAXNCON][2];
int higain, oldgain, mincut, newcut, mincutorder;
int qsizes[MAXNCON][2];
nvtxs = graph->nvtxs;
ncon = graph->ncon;
xadj = graph->xadj;
nvwgt = graph->nvwgt;
adjncy = graph->adjncy;
adjwgt = graph->adjwgt;
where = graph->where;
id = graph->id;
ed = graph->ed;
npwgts = graph->npwgts;
bndptr = graph->bndptr;
bndind = graph->bndind;
moved = idxwspacemalloc(ctrl, nvtxs);
swaps = idxwspacemalloc(ctrl, nvtxs);
perm = idxwspacemalloc(ctrl, nvtxs);
qnum = idxwspacemalloc(ctrl, nvtxs);
limit = amin(amax(0.01*nvtxs, 15), 100);
/* Initialize the queues */
for (i=0; i<ncon; i++) {
PQueueInit(ctrl, &parts[i][0], nvtxs, PLUS_GAINSPAN+1);
PQueueInit(ctrl, &parts[i][1], nvtxs, PLUS_GAINSPAN+1);
qsizes[i][0] = qsizes[i][1] = 0;
}
for (i=0; i<nvtxs; i++) {
qnum[i] = samax(ncon, nvwgt+i*ncon);
qsizes[qnum[i]][where[i]]++;
}
/*
printf("Weight Distribution: \t");
for (i=0; i<ncon; i++)
printf(" [%d %d]", qsizes[i][0], qsizes[i][1]);
printf("\n");
*/
for (from=0; from<2; from++) {
for (j=0; j<ncon; j++) {
if (qsizes[j][from] == 0) {
for (i=0; i<nvtxs; i++) {
if (where[i] != from)
continue;
k = samax2(ncon, nvwgt+i*ncon);
if (k == j && qsizes[qnum[i]][from] > qsizes[j][from] && nvwgt[i*ncon+qnum[i]] < 1.3*nvwgt[i*ncon+j]) {
qsizes[qnum[i]][from]--;
qsizes[j][from]++;
qnum[i] = j;
}
}
}
}
}
/*
printf("Weight Distribution (after):\t ");
for (i=0; i<ncon; i++)
printf(" [%d %d]", qsizes[i][0], qsizes[i][1]);
printf("\n");
*/
for (i=0; i<ncon; i++)
mindiff[i] = fabs(tpwgts[0]-npwgts[i]);
minbal = origbal = Compute2WayHLoadImbalance(ncon, npwgts, tpwgts);
newcut = mincut = graph->mincut;
mincutorder = -1;
if (ctrl->dbglvl&DBG_REFINE) {
printf("Parts: [");
for (l=0; l<ncon; l++)
printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
printf("] T[%.3f %.3f], Nv-Nb[%5d, %5d]. ICut: %6d, LB: %.3f [B]\n", tpwgts[0], tpwgts[1], graph->nvtxs, graph->nbnd, graph->mincut, origbal);
}
idxset(nvtxs, -1, moved);
ASSERT(ComputeCut(graph, where) == graph->mincut);
ASSERT(CheckBnd(graph));
/* Insert all nodes in the priority queues */
nbnd = graph->nbnd;
RandomPermute(nvtxs, perm, 1);
for (ii=0; ii<nvtxs; ii++) {
i = perm[ii];
PQueueInsert(&parts[qnum[i]][where[i]], i, ed[i]-id[i]);
}
for (nswaps=0; nswaps<nvtxs; nswaps++) {
if (minbal < lbfactor)
break;
SelectQueue(ncon, npwgts, tpwgts, &from, &cnum, parts);
to = (from+1)%2;
if (from == -1 || (higain = PQueueGetMax(&parts[cnum][from])) == -1)
break;
saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1);
newcut -= (ed[higain]-id[higain]);
newbal = Compute2WayHLoadImbalance(ncon, npwgts, tpwgts);
if (newbal < minbal || (newbal == minbal &&
(newcut < mincut || (newcut == mincut && BetterBalance(ncon, npwgts, tpwgts, mindiff))))) {
mincut = newcut;
minbal = newbal;
mincutorder = nswaps;
for (i=0; i<ncon; i++)
mindiff[i] = fabs(tpwgts[0]-npwgts[i]);
}
else if (nswaps-mincutorder > limit) { /* We hit the limit, undo last move */
newcut += (ed[higain]-id[higain]);
saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1);
saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
break;
}
where[higain] = to;
moved[higain] = nswaps;
swaps[nswaps] = higain;
if (ctrl->dbglvl&DBG_MOVEINFO) {
printf("Moved %6d from %d(%d). Gain: %5d, Cut: %5d, NPwgts: ", higain, from, cnum, ed[higain]-id[higain], newcut);
for (l=0; l<ncon; l++)
printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
printf(", %.3f LB: %.3f\n", minbal, newbal);
}
/**************************************************************
* Update the id[i]/ed[i] values of the affected nodes
***************************************************************/
SWAP(id[higain], ed[higain], tmp);
if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1])
BNDDelete(nbnd, bndind, bndptr, higain);
if (ed[higain] > 0 && bndptr[higain] == -1)
BNDInsert(nbnd, bndind, bndptr, higain);
for (j=xadj[higain]; j<xadj[higain+1]; j++) {
k = adjncy[j];
oldgain = ed[k]-id[k];
kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
INC_DEC(id[k], ed[k], kwgt);
/* Update the queue position */
if (moved[k] == -1)
PQueueUpdate(&parts[qnum[k]][where[k]], k, oldgain, ed[k]-id[k]);
/* Update its boundary information */
if (ed[k] == 0 && bndptr[k] != -1)
BNDDelete(nbnd, bndind, bndptr, k);
else if (ed[k] > 0 && bndptr[k] == -1)
BNDInsert(nbnd, bndind, bndptr, k);
}
}
/****************************************************************
* Roll back computations
*****************************************************************/
for (nswaps--; nswaps>mincutorder; nswaps--) {
higain = swaps[nswaps];
to = where[higain] = (where[higain]+1)%2;
SWAP(id[higain], ed[higain], tmp);
if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1])
BNDDelete(nbnd, bndind, bndptr, higain);
else if (ed[higain] > 0 && bndptr[higain] == -1)
BNDInsert(nbnd, bndind, bndptr, higain);
saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+((to+1)%2)*ncon, 1);
for (j=xadj[higain]; j<xadj[higain+1]; j++) {
k = adjncy[j];
kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
INC_DEC(id[k], ed[k], kwgt);
if (bndptr[k] != -1 && ed[k] == 0)
BNDDelete(nbnd, bndind, bndptr, k);
if (bndptr[k] == -1 && ed[k] > 0)
BNDInsert(nbnd, bndind, bndptr, k);
}
}
if (ctrl->dbglvl&DBG_REFINE) {
printf("\tMincut: %6d at %5d, NBND: %6d, NPwgts: [", mincut, mincutorder, nbnd);
for (l=0; l<ncon; l++)
printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
printf("], LB: %.3f\n", Compute2WayHLoadImbalance(ncon, npwgts, tpwgts));
}
graph->mincut = mincut;
graph->nbnd = nbnd;
for (i=0; i<ncon; i++) {
PQueueFree(ctrl, &parts[i][0]);
PQueueFree(ctrl, &parts[i][1]);
}
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
}
//-----------------------------------------------------------------------------
// Does the given point lie on our shell? There are many cases; inside and
// outside are obvious, but then there's all the edge-on-edge and edge-on-face
// possibilities.
//
// To calculate, we intersect a ray through p with our shell, and classify
// using the closest intersection point. If the ray hits a surface on edge,
// then just reattempt in a different random direction.
//-----------------------------------------------------------------------------
bool SShell::ClassifyEdge(int *indir, int *outdir,
Vector ea, Vector eb,
Vector p,
Vector edge_n_in, Vector edge_n_out, Vector surf_n)
{
List<SInter> l;
ZERO(&l);
srand(0);
// First, check for edge-on-edge
int edge_inters = 0;
Vector inter_surf_n[2], inter_edge_n[2];
SSurface *srf;
for(srf = surface.First(); srf; srf = surface.NextAfter(srf)) {
if(srf->LineEntirelyOutsideBbox(ea, eb, true)) continue;
SEdgeList *sel = &(srf->edges);
SEdge *se;
for(se = sel->l.First(); se; se = sel->l.NextAfter(se)) {
if((ea.Equals(se->a) && eb.Equals(se->b)) ||
(eb.Equals(se->a) && ea.Equals(se->b)) ||
p.OnLineSegment(se->a, se->b))
{
if(edge_inters < 2) {
// Edge-on-edge case
Point2d pm;
srf->ClosestPointTo(p, &pm, false);
// A vector normal to the surface, at the intersection point
inter_surf_n[edge_inters] = srf->NormalAt(pm);
// A vector normal to the intersecting edge (but within the
// intersecting surface) at the intersection point, pointing
// out.
inter_edge_n[edge_inters] =
(inter_surf_n[edge_inters]).Cross((se->b).Minus((se->a)));
}
edge_inters++;
}
}
}
if(edge_inters == 2) {
// TODO, make this use the appropriate curved normals
double dotp[2];
for(int i = 0; i < 2; i++) {
dotp[i] = edge_n_out.DirectionCosineWith(inter_surf_n[i]);
}
if(fabs(dotp[1]) < DOTP_TOL) {
SWAP(double, dotp[0], dotp[1]);
SWAP(Vector, inter_surf_n[0], inter_surf_n[1]);
SWAP(Vector, inter_edge_n[0], inter_edge_n[1]);
}
int coinc = (surf_n.Dot(inter_surf_n[0])) > 0 ? COINC_SAME : COINC_OPP;
if(fabs(dotp[0]) < DOTP_TOL && fabs(dotp[1]) < DOTP_TOL) {
// This is actually an edge on face case, just that the face
// is split into two pieces joining at our edge.
*indir = coinc;
*outdir = coinc;
} else if(fabs(dotp[0]) < DOTP_TOL && dotp[1] > DOTP_TOL) {
if(edge_n_out.Dot(inter_edge_n[0]) > 0) {
*indir = coinc;
*outdir = OUTSIDE;
} else {
*indir = INSIDE;
*outdir = coinc;
}
} else if(fabs(dotp[0]) < DOTP_TOL && dotp[1] < -DOTP_TOL) {
if(edge_n_out.Dot(inter_edge_n[0]) > 0) {
*indir = coinc;
*outdir = INSIDE;
} else {
*indir = OUTSIDE;
*outdir = coinc;
}
} else if(dotp[0] > DOTP_TOL && dotp[1] > DOTP_TOL) {
*indir = INSIDE;
*outdir = OUTSIDE;
} else if(dotp[0] < -DOTP_TOL && dotp[1] < -DOTP_TOL) {
*indir = OUTSIDE;
*outdir = INSIDE;
} else {
// Edge is tangent to the shell at shell's edge, so can't be
// a boundary of the surface.
return false;
}
return true;
}
if(edge_inters != 0) dbp("bad, edge_inters=%d", edge_inters);
// Next, check for edge-on-surface. The ray-casting for edge-inside-shell
// would catch this too, but test separately, for speed (since many edges
// are on surface) and for numerical stability, so we don't pick up
// the additional error from the line intersection.
for(srf = surface.First(); srf; srf = surface.NextAfter(srf)) {
if(srf->LineEntirelyOutsideBbox(ea, eb, true)) continue;
Point2d puv;
srf->ClosestPointTo(p, &(puv.x), &(puv.y), false);
Vector pp = srf->PointAt(puv);
if((pp.Minus(p)).Magnitude() > LENGTH_EPS) continue;
Point2d dummy = { 0, 0 };
int c = srf->bsp->ClassifyPoint(puv, dummy, srf);
if(c == SBspUv::OUTSIDE) continue;
// Edge-on-face (unless edge-on-edge above superceded)
Point2d pin, pout;
srf->ClosestPointTo(p.Plus(edge_n_in), &pin, false);
srf->ClosestPointTo(p.Plus(edge_n_out), &pout, false);
Vector surf_n_in = srf->NormalAt(pin),
surf_n_out = srf->NormalAt(pout);
*indir = ClassifyRegion(edge_n_in, surf_n_in, surf_n);
*outdir = ClassifyRegion(edge_n_out, surf_n_out, surf_n);
return true;
}
// Edge is not on face or on edge; so it's either inside or outside
// the shell, and we'll determine which by raycasting.
int cnt = 0;
for(;;) {
// Cast a ray in a random direction (two-sided so that we test if
// the point lies on a surface, but use only one side for in/out
// testing)
Vector ray = Vector::From(Random(1), Random(1), Random(1));
AllPointsIntersecting(
p.Minus(ray), p.Plus(ray), &l, false, true, false);
// no intersections means it's outside
*indir = OUTSIDE;
*outdir = OUTSIDE;
double dmin = VERY_POSITIVE;
bool onEdge = false;
edge_inters = 0;
SInter *si;
for(si = l.First(); si; si = l.NextAfter(si)) {
double t = ((si->p).Minus(p)).DivPivoting(ray);
if(t*ray.Magnitude() < -LENGTH_EPS) {
// wrong side, doesn't count
continue;
}
double d = ((si->p).Minus(p)).Magnitude();
// We actually should never hit this case; it should have been
// handled above.
if(d < LENGTH_EPS && si->onEdge) {
edge_inters++;
}
if(d < dmin) {
dmin = d;
// Edge does not lie on surface; either strictly inside
// or strictly outside
if((si->surfNormal).Dot(ray) > 0) {
*indir = INSIDE;
*outdir = INSIDE;
} else {
*indir = OUTSIDE;
*outdir = OUTSIDE;
}
onEdge = si->onEdge;
}
}
l.Clear();
// If the point being tested lies exactly on an edge of the shell,
// then our ray always lies on edge, and that's okay. Otherwise
// try again in a different random direction.
if(!onEdge) break;
if(cnt++ > 5) {
dbp("can't find a ray that doesn't hit on edge!");
dbp("on edge = %d, edge_inters = %d", onEdge, edge_inters);
SS.nakedEdges.AddEdge(ea, eb);
break;
}
}
return true;
}
/*************************************************************************
* This function balances two partitions by moving the highest gain
* (including negative gain) vertices to the other domain.
* It is used only when tha unbalance is due to non contigous
* subdomains. That is, the are no boundary vertices.
* It moves vertices from the domain that is overweight to the one that
* is underweight.
**************************************************************************/
void MocInit2WayBalance(CtrlType *ctrl, GraphType *graph, float *tpwgts)
{
int i, ii, j, k, l, kwgt, nvtxs, nbnd, ncon, nswaps, from, to, pass, me, cnum, tmp;
idxtype *xadj, *adjncy, *adjwgt, *where, *id, *ed, *bndptr, *bndind;
idxtype *perm, *qnum;
float *nvwgt, *npwgts;
PQueueType parts[MAXNCON][2];
int higain, oldgain, mincut;
nvtxs = graph->nvtxs;
ncon = graph->ncon;
xadj = graph->xadj;
adjncy = graph->adjncy;
nvwgt = graph->nvwgt;
adjwgt = graph->adjwgt;
where = graph->where;
id = graph->id;
ed = graph->ed;
npwgts = graph->npwgts;
bndptr = graph->bndptr;
bndind = graph->bndind;
perm = idxwspacemalloc(ctrl, nvtxs);
qnum = idxwspacemalloc(ctrl, nvtxs);
/* This is called for initial partitioning so we know from where to pick nodes */
from = 1;
to = (from+1)%2;
if (ctrl->dbglvl&DBG_REFINE) {
printf("Parts: [");
for (l=0; l<ncon; l++)
printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
printf("] T[%.3f %.3f], Nv-Nb[%5d, %5d]. ICut: %6d, LB: %.3f [B]\n", tpwgts[0], tpwgts[1],
graph->nvtxs, graph->nbnd, graph->mincut,
Compute2WayHLoadImbalance(ncon, npwgts, tpwgts));
}
for (i=0; i<ncon; i++) {
PQueueInit(ctrl, &parts[i][0], nvtxs, PLUS_GAINSPAN+1);
PQueueInit(ctrl, &parts[i][1], nvtxs, PLUS_GAINSPAN+1);
}
ASSERT(ComputeCut(graph, where) == graph->mincut);
ASSERT(CheckBnd(graph));
ASSERT(CheckGraph(graph));
/* Compute the queues in which each vertex will be assigned to */
for (i=0; i<nvtxs; i++)
qnum[i] = samax(ncon, nvwgt+i*ncon);
/* Insert the nodes of the proper partition in the appropriate priority queue */
RandomPermute(nvtxs, perm, 1);
for (ii=0; ii<nvtxs; ii++) {
i = perm[ii];
if (where[i] == from) {
if (ed[i] > 0)
PQueueInsert(&parts[qnum[i]][0], i, ed[i]-id[i]);
else
PQueueInsert(&parts[qnum[i]][1], i, ed[i]-id[i]);
}
}
mincut = graph->mincut;
nbnd = graph->nbnd;
for (nswaps=0; nswaps<nvtxs; nswaps++) {
if (AreAnyVwgtsBelow(ncon, 1.0, npwgts+from*ncon, 0.0, nvwgt, tpwgts[from]))
break;
if ((cnum = SelectQueueOneWay(ncon, npwgts, tpwgts, from, parts)) == -1)
break;
if ((higain = PQueueGetMax(&parts[cnum][0])) == -1)
higain = PQueueGetMax(&parts[cnum][1]);
mincut -= (ed[higain]-id[higain]);
saxpy(ncon, 1.0, nvwgt+higain*ncon, 1, npwgts+to*ncon, 1);
saxpy(ncon, -1.0, nvwgt+higain*ncon, 1, npwgts+from*ncon, 1);
where[higain] = to;
if (ctrl->dbglvl&DBG_MOVEINFO) {
printf("Moved %6d from %d(%d). [%5d] %5d, NPwgts: ", higain, from, cnum, ed[higain]-id[higain], mincut);
for (l=0; l<ncon; l++)
printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
printf(", LB: %.3f\n", Compute2WayHLoadImbalance(ncon, npwgts, tpwgts));
if (ed[higain] == 0 && id[higain] > 0)
printf("\t Pulled from the interior!\n");
}
/**************************************************************
* Update the id[i]/ed[i] values of the affected nodes
***************************************************************/
SWAP(id[higain], ed[higain], tmp);
if (ed[higain] == 0 && bndptr[higain] != -1 && xadj[higain] < xadj[higain+1])
BNDDelete(nbnd, bndind, bndptr, higain);
if (ed[higain] > 0 && bndptr[higain] == -1)
BNDInsert(nbnd, bndind, bndptr, higain);
for (j=xadj[higain]; j<xadj[higain+1]; j++) {
k = adjncy[j];
oldgain = ed[k]-id[k];
kwgt = (to == where[k] ? adjwgt[j] : -adjwgt[j]);
INC_DEC(id[k], ed[k], kwgt);
/* Update the queue position */
if (where[k] == from) {
if (ed[k] > 0 && bndptr[k] == -1) { /* It moves in boundary */
PQueueDelete(&parts[qnum[k]][1], k, oldgain);
PQueueInsert(&parts[qnum[k]][0], k, ed[k]-id[k]);
}
else { /* It must be in the boundary already */
if (bndptr[k] == -1)
printf("What you thought was wrong!\n");
PQueueUpdate(&parts[qnum[k]][0], k, oldgain, ed[k]-id[k]);
}
}
/* Update its boundary information */
if (ed[k] == 0 && bndptr[k] != -1)
BNDDelete(nbnd, bndind, bndptr, k);
else if (ed[k] > 0 && bndptr[k] == -1)
BNDInsert(nbnd, bndind, bndptr, k);
}
ASSERTP(ComputeCut(graph, where) == mincut, ("%d != %d\n", ComputeCut(graph, where), mincut));
}
if (ctrl->dbglvl&DBG_REFINE) {
printf("\tMincut: %6d, NBND: %6d, NPwgts: ", mincut, nbnd);
for (l=0; l<ncon; l++)
printf("(%.3f, %.3f) ", npwgts[l], npwgts[ncon+l]);
printf(", LB: %.3f\n", Compute2WayHLoadImbalance(ncon, npwgts, tpwgts));
}
graph->mincut = mincut;
graph->nbnd = nbnd;
for (i=0; i<ncon; i++) {
PQueueFree(ctrl, &parts[i][0]);
PQueueFree(ctrl, &parts[i][1]);
}
ASSERT(ComputeCut(graph, where) == graph->mincut);
ASSERT(CheckBnd(graph));
idxwspacefree(ctrl, nvtxs);
idxwspacefree(ctrl, nvtxs);
}
bool Obstacles::mergePolygons(Polygon &polyA, Polygon &polyB) {
bool flagDidMergePolygons = false;
Polygon polyMerged;
polyMerged.rect = merge(polyA.rect, polyB.rect);
Polygon *polyPrimary, *polySecondary;
if (polyA.rect.y0 < polyB.rect.y0 || (polyA.rect.y0 == polyB.rect.y0 && polyA.rect.x0 < polyB.rect.x0)) {
polyPrimary = &polyA;
polySecondary = &polyB;
} else {
polyPrimary = &polyB;
polySecondary = &polyA;
}
Vector2 intersectionPoint;
LineSegment polyLine;
bool flagAddVertexToVertexList = true;
bool flagDidFindIntersection = false;
int vertIndex = 0;
Polygon *startingPolygon = polyPrimary;
int flagDone = false;
while (!flagDone) {
VertexType polyPrimaryType;
polyLine.start = flagDidFindIntersection ? intersectionPoint : polyPrimary->vertices[vertIndex];
polyLine.end = polyPrimary->vertices[(vertIndex + 1) % polyPrimary->verticeCount];
// TODO(madmoose): How does this work when adding a new intersection point?
polyPrimaryType = polyPrimary->vertexType[vertIndex];
if (flagAddVertexToVertexList) {
assert(polyMerged.verticeCount < kPolygonVertexCount);
polyMerged.vertices[polyMerged.verticeCount] = polyLine.start;
polyMerged.vertexType[polyMerged.verticeCount] = polyPrimaryType;
polyMerged.verticeCount++;
}
flagAddVertexToVertexList = true;
int polySecondaryIntersectionIndex = -1;
if (linePolygonIntersection(polyLine, polyPrimaryType, polySecondary, &intersectionPoint, &polySecondaryIntersectionIndex)) {
if (WITHIN_TOLERANCE(intersectionPoint.x, polyLine.start.x) && WITHIN_TOLERANCE(intersectionPoint.y, polyLine.start.y)) {
warning("Set: %d Scene: %d", _vm->_scene->getSetId(), _vm->_scene->getSceneId());
assert(0 && "Report instances of this to madmoose!");
flagAddVertexToVertexList = false;
polyMerged.verticeCount--; // TODO(madmoose): How would this work?
} else {
// Obstacles::nop
}
vertIndex = polySecondaryIntersectionIndex;
flagDidFindIntersection = true;
SWAP(polyPrimary, polySecondary);
flagDidMergePolygons = true;
} else {
vertIndex = (vertIndex + 1) % polyPrimary->verticeCount;
flagDidFindIntersection = false;
}
if (polyPrimary->vertices[vertIndex] == startingPolygon->vertices[0]) {
flagDone = true;
}
}
if (flagDidMergePolygons) {
*startingPolygon = polyMerged;
startingPolygon->isPresent = true;
if (startingPolygon == &polyA) {
polyB.isPresent = false;
} else {
polyA.isPresent = false;
}
}
return flagDidMergePolygons;
}