void shell_sort(void *base, size_t nelem, size_t width, FCMP fcmp)
{
int i, j, k, h;
void *v;
v = malloc(width);
for (h = 1; h < nelem; h = 3*h+1);
for (h /= 3; h > 0; h /= 3)
{
for (i = 0; i < h; i++)
{
for (j = i+h; j < nelem; j += h)
{
memcpy(v, BASE(j), width);
k = j;
while (k > h-1 && fcmp(BASE(k-h), v) > 0)
{
memcpy(BASE(k),BASE(k-h),width);
k -= h;
}
memcpy(BASE(k), v, width);
}
}
}
free(v);
}
/**
* Output a single char.
* Note: We allow only to put a char on the last line.
*/
int
out_char(unsigned value)
{
#define BASE(ROW) ((unsigned short *) (0xb8000+ROW*160))
static unsigned int col;
if (value!='\n')
{
unsigned short *p = BASE(24)+col;
*p = 0x0f00 | value;
col++;
}
if (col>=80 || value == '\n')
{
col=0;
unsigned short *p=BASE(0);
memcpy(p, p+80, 24*160);
memset(BASE(24), 0, 160);
}
serial_send(value);
if (value == '\n')
serial_send('\r');
return value;
}
void *post_ctor(post *self) {
((void_fun) (klass_of(self)->super->ctor))(self);
(BASE(self))->field_count = 5;
(BASE(self))->current = 0;
(BASE(self))->form_datas = (form_data **) malloc(sizeof(form_data *) * 5);
(BASE(self))->field_tables = (char **) malloc(sizeof(char *) * 5);
return self;
}
void *lv_delete(void *key, void *base, size_t *num, size_t width, FCMP fcmp)
{
void *ip;
int i;
if (*num > 0)
{
if ((ip = lv_search(key, base, num, width, fcmp)) == NULL)
return NULL;
for (i = ((char*)ip - (char*)base)/width+1; i < *num; i++)
memcpy(BASE(i-1), BASE(i), width);
(*num)--;
return ip;
}
return NULL;
}
static void gf32m_init(element_t e) {
e->data = pbc_malloc(sizeof(gf32m_s));
gf32m_ptr p = (gf32m_ptr) e->data;
field_ptr base = BASE(e);
element_init(p->_0, base);
element_init(p->_1, base);
}
static Bit32u calculate_sib(unsigned char **lina, Bit8u mod)
{
Bit8u sib = **lina;
int ss = SCALE(sib);
int index = INDEX(sib);
int base = BASE(sib);
u_int addr = 0;
(*lina) ++; /* past SIB */
if (index != 4) {
addr = (1<<ss) * get_reg(index, 4);
}
if (base == 5) {
addr += *(Bit32u*)(*lina);
(*lina) += 4; /* past disp32 */
if (mod != 0) {
addr += get_reg(REGNO_EBP, 4);
}
} else {
addr += get_reg(base, 4);
}
return addr;
}
/* $e<- a*b$ */
static void gf32m_mult(element_t e, element_t a, element_t b) {
element_ptr a0 = GF32M(a)->_0, a1 = GF32M(a)->_1, b0 = GF32M(b)->_0, b1 =
GF32M(b)->_1, e0 = GF32M(e)->_0, e1 = GF32M(e)->_1;
field_ptr base = BASE(a);
element_t a0b0, a1b1, t0, t1, c1;
element_init(a0b0, base);
element_init(a1b1, base);
element_init(t0, base);
element_init(t1, base);
element_init(c1, base);
element_mul(a0b0, a0, b0);
element_mul(a1b1, a1, b1);
element_add(t0, a1, a0);
element_add(t1, b1, b0);
element_mul(c1, t0, t1); // c1 == (a1+a0)*(b1+b0)
element_sub(c1, c1, a1b1);
element_sub(c1, c1, a0b0);
element_ptr c0 = a0b0;
element_sub(c0, c0, a1b1); // c0 == a0*b0 - a1*b1
element_set(e0, c0);
element_set(e1, c1);
element_clear(a0b0);
element_clear(a1b1);
element_clear(t0);
element_clear(t1);
element_clear(c1);
}
_Automaton::_Automaton()
{
BASE();
m_nState = 0;
m_iState = 0;
}
Condition( const Matrix<F>& A, NormType type=TWO_NORM )
{
DEBUG_ONLY(CallStackEntry cse("Condition"))
BASE(F) norm = 0;
switch( type )
{
case FROBENIUS_NORM:
norm = FrobeniusCondition( A );
break;
case INFINITY_NORM:
norm = InfinityCondition( A );
break;
case MAX_NORM:
norm = MaxCondition( A );
break;
case ONE_NORM:
norm = OneCondition( A );
break;
case TWO_NORM:
norm = TwoCondition( A );
break;
default:
LogicError("Invalid norm type for condition number");
}
return norm;
}
Condition( const DistMatrix<F,U,V>& A, NormType type=TWO_NORM )
{
#ifndef RELEASE
CallStackEntry entry("Condition");
#endif
BASE(F) norm = 0;
switch( type )
{
case FROBENIUS_NORM:
norm = FrobeniusCondition( A );
break;
case INFINITY_NORM:
norm = InfinityCondition( A );
break;
case MAX_NORM:
norm = MaxCondition( A );
break;
case ONE_NORM:
norm = OneCondition( A );
break;
case TWO_NORM:
norm = TwoCondition( A );
break;
default:
LogicError("Invalid norm type for condition number");
}
return norm;
}
static void point_init(element_t e) {
field_ptr f = BASE(e);
e->data = pbc_malloc(sizeof(struct point_s));
point_ptr p = DATA(e);
element_init(p->x, f);
element_init(p->y, f);
p->isinf = 1;
}
/* $e <- a^{-1}$ */
static void gf33m_invert(element_t e, element_t a) {
element_ptr a0 = GF33M(a)->_0, a1 = GF33M(a)->_1, a2 = GF33M(a)->_2, e0 =
GF33M(e)->_0, e1 = GF33M(e)->_1, e2 = GF33M(e)->_2;
field_ptr base = BASE(e);
element_t a02, a12, a22;
element_init(a02, base);
element_init(a12, base);
element_init(a22, base);
element_mul(a02, a0, a0);
element_mul(a12, a1, a1);
element_mul(a22, a2, a2);
element_t v0;
element_init(v0, base);
element_sub(v0, a0, a2); // v0 == a0-a2
element_t delta;
element_init(delta, base);
element_mul(delta, v0, a02); // delta = (a0-a2)*(a0^2), free
element_sub(v0, a1, a0); // v0 == a1-a0
element_t c0;
element_init(c0, base);
element_mul(c0, v0, a12); // c0 == (a1-a0)*(a1^2)
element_add(delta, delta, c0); // delta = (a0-a2)*(a0^2) + (a1-a0)*(a1^2)
element_sub(v0, a2, v0); // v0 == a2-(a1-a0) = a0-a1+a2
element_t c1;
element_init(c1, base);
element_mul(c1, v0, a22); // c1 == (a0-a1+a2)*(a2^2)
element_add(delta, delta, c1); // delta = (a0-a2)*(a0^2) + (a1-a0)*(a1^2) + (a0-a1+a2)*(a2^2)
element_invert(delta, delta); // delta = [(a0-a2)*(a0^2) + (a1-a0)*(a1^2) + (a0-a1+a2)*(a2^2)] ^ {-1}
element_add(v0, a02, a22); // v0 == a0^2+a2^2
element_t c2;
element_init(c2, base);
element_mul(c2, a0, a2); // c2 == a0*a2
element_sub(c0, v0, c2); // c0 == a0^2+a2^2-a0*a2
element_add(v0, a1, a2); // v0 == a1+a2
element_t c3;
element_init(c3, base);
element_mul(c3, a1, v0); // c3 == a1*(a1+a2)
element_sub(c0, c0, c3); // c0 == a0^2+a2^2-a0*a2-a1*(a1+a2)
element_mul(c0, c0, delta); // c0 *= delta
element_mul(c1, a0, a1); // c1 == a0*a1
element_sub(c1, a22, c1); // c1 == a2^2-a0*a1
element_mul(c1, c1, delta); // c1 *= delta
element_sub(c2, a12, c2); // c2 == a1^2-a0*a2
element_sub(c2, c2, a22); // c2 == a1^2-a0*a2-a2^2
element_mul(c2, c2, delta); // c2 *= delta
element_set(e0, c0);
element_set(e1, c1);
element_set(e2, c2);
element_clear(a02);
element_clear(a12);
element_clear(a22);
element_clear(v0);
element_clear(delta);
element_clear(c0);
element_clear(c1);
element_clear(c2);
element_clear(c3);
}
/* $c <- a*b$ */
static void gf33m_mult(element_t e, element_t a, element_t b) {
element_ptr a0 = GF33M(a)->_0, a1 = GF33M(a)->_1, a2 = GF33M(a)->_2, b0 =
GF33M(b)->_0, b1 = GF33M(b)->_1, b2 = GF33M(b)->_2, e0 =
GF33M(e)->_0, e1 = GF33M(e)->_1, e2 = GF33M(e)->_2;
field_ptr base = BASE(e);
element_t t0, t1, c1, a0b0, a1b1, a2b2;
element_init(t0, base);
element_init(t1, base);
element_init(c1, base);
element_init(a0b0, base);
element_init(a1b1, base);
element_init(a2b2, base);
element_mul(a0b0, a0, b0);
element_mul(a1b1, a1, b1);
element_mul(a2b2, a2, b2);
element_ptr d0 = a0b0;
element_add(t0, a1, a0);
element_add(t1, b1, b0);
element_t d1;
element_init(d1, base);
element_mul(d1, t0, t1);
element_sub(d1, d1, a1b1);
element_sub(d1, d1, a0b0);
element_add(t0, a2, a0);
element_add(t1, b2, b0);
element_t d2;
element_init(d2, base);
element_mul(d2, t0, t1);
element_add(d2, d2, a1b1);
element_sub(d2, d2, a2b2);
element_sub(d2, d2, a0b0);
element_add(t0, a2, a1);
element_add(t1, b2, b1);
element_t d3;
element_init(d3, base);
element_mul(d3, t0, t1);
element_sub(d3, d3, a2b2);
element_sub(d3, d3, a1b1);
element_ptr d4 = a2b2;
element_add(t0, d0, d3);
element_ptr c0 = t0;
element_add(c1, d1, d3);
element_add(c1, c1, d4);
element_add(t1, d2, d4);
element_ptr c2 = t1;
element_set(e0, c0);
element_set(e1, c1);
element_set(e2, c2);
element_clear(t0);
element_clear(t1);
element_clear(c1);
element_clear(a0b0);
element_clear(a1b1);
element_clear(a2b2);
element_clear(d1);
element_clear(d2);
element_clear(d3);
}
void insert_sort(void*base, size_t nelem, size_t width, FCMP fcmp)
{
int i, j;
void *t;
t = malloc(width);
for (i = 1; i < nelem; i++)
{
memcpy(t, BASE(i), width);
j = i;
while (fcmp(BASE(j-1), t) > 0 && j > 0)
{
memcpy(BASE(j), BASE(j-1), width);
j--;
}
memcpy(BASE(j), t, width);
}
free(t);
}
void wangpc_emb_device::wangpcbus_amwc_w(offs_t offset, uint16_t mem_mask, uint16_t data)
{
for (int bank = 0; bank < 4; bank++)
{
if (ENABLE(bank) && (A19_A18_A17 == BASE(bank)))
{
RAM_BANK(bank) = data;
}
}
}
void wangpc_emb_device::wangpcbus_amwc_w(address_space &space, offs_t offset, UINT16 mem_mask, UINT16 data)
{
for (int bank = 0; bank < 4; bank++)
{
if (ENABLE(bank) && (A19_A18_A17 == BASE(bank)))
{
RAM_BANK(bank) = data;
}
}
}
static void i80286_data_descriptor_full(i80286_state *cpustate, int reg, UINT16 selector, int cpl, UINT32 trap, UINT16 offset, int size)
{
if (PM) {
UINT16 desc[3];
UINT8 r;
UINT32 addr;
/* selector format
15..3 number/address in descriptor table
2: 0 global, 1 local descriptor table
1,0: requested privileg level
must be higher or same as current privileg level in code selector */
if ((reg != SS) && !IDXTBL(selector)) {
cpustate->sregs[reg]=0;
cpustate->limit[reg]=0;
cpustate->base[reg]=0;
cpustate->rights[reg]=0;
cpustate->valid[reg]=0;
return;
}
if ((addr = i80286_selector_address(cpustate,selector)) == -1) throw trap;
desc[0] = ReadWord(addr);
desc[1] = ReadWord(addr+2);
desc[2] = ReadWord(addr+4);
r = RIGHTS(desc);
if (!SEGDESC(r)) throw trap;
if (reg == SS) {
if (!IDXTBL(selector)) throw trap;
if (DPL(r)!=cpl) throw trap;
if (RPL(selector)!=cpl) throw trap;
if (!RW(r) || CODE(r)) throw trap;
if (!PRES(r)) throw TRAP(STACK_FAULT,(IDXTBL(selector)+(trap&1)));
} else {
if ((DPL(r) < PMAX(cpl,RPL(selector))) && (!CODE(r) || (CODE(r) && !CONF(r)))) throw trap;
if (CODE(r) && !READ(r)) throw trap;
if (!PRES(r)) throw TRAP(SEG_NOT_PRESENT,(IDXTBL(selector)+(trap&1)));
}
if (offset+size) {
if ((CODE(r) || !EXPDOWN(r)) && ((offset+size-1) > LIMIT(desc))) throw (reg==SS)?TRAP(STACK_FAULT,(trap&1)):trap;
if (!CODE(r) && EXPDOWN(r) && ((offset <= LIMIT(desc)) || ((offset+size-1) > 0xffff))) throw (reg==SS)?TRAP(STACK_FAULT,(trap&1)):trap;
}
SET_ACC(desc);
WriteWord(addr+4, desc[2]);
cpustate->sregs[reg]=selector;
cpustate->limit[reg]=LIMIT(desc);
cpustate->base[reg]=BASE(desc);
cpustate->rights[reg]=RIGHTS(desc);
} else {
cpustate->sregs[reg]=selector;
cpustate->base[reg]=selector<<4;
}
cpustate->valid[reg]=1;
}
form_data *post_get_field_value(post *self, char *field_name) {
form_data *current_post_data = getFieldValue((BASE(self)), field_name);
if (current_post_data) {
#ifdef SHOW_FIELD_KEY_VALUE
fprintf(cgiOut, "%s = %s<br/>", current_post_data->field_name,
current_post_data->field_value);
#endif
return current_post_data;
}
return NULL;
}
UINT16 wangpc_emb_device::wangpcbus_mrdc_r(address_space &space, offs_t offset, UINT16 mem_mask)
{
UINT16 data = 0xffff;
for (int bank = 0; bank < 4; bank++)
{
if (ENABLE(bank) && (A19_A18_A17 == BASE(bank)))
{
data &= RAM_BANK(bank);
}
}
return data;
}
uint16_t wangpc_emb_device::wangpcbus_mrdc_r(offs_t offset, uint16_t mem_mask)
{
uint16_t data = 0xffff;
for (int bank = 0; bank < 4; bank++)
{
if (ENABLE(bank) && (A19_A18_A17 == BASE(bank)))
{
data &= RAM_BANK(bank);
}
}
return data;
}
/* $e <- a^3$ */
static void gf32m_cubic(element_t e, element_t a) {
element_ptr a0 = GF32M(a)->_0, a1 = GF32M(a)->_1, e0 = GF32M(e)->_0, e1 =
GF32M(e)->_1;
field_ptr base = BASE(a);
element_t c0, c1;
element_init(c0, base);
element_init(c1, base);
element_cubic(c0, a0);
element_cubic(c1, a1);
element_neg(c1, c1); // c1 == -(a1^3)
element_set(e0, c0);
element_set(e1, c1);
element_clear(c0);
element_clear(c1);
}
void *lfv_search(void *key, void *base, size_t *num, size_t width, FCMP fcmp)
{
int i = 0, j;
void *v;
while (fcmp(BASE(i), key) != 0 && i < *num) i++;
if (i >= *num) return NULL;
v = malloc(width);
memcpy(v, BASE(i), width);
for (j = i+1; j < *num; j++)
memcpy(BASE(j-1), BASE(j), width);
for (j = *num-2; j >= 0; j--)
memcpy(BASE(j+1), BASE(j), width);
memcpy(base, v, width);
return BASE(i);
}
/*------------------------------------------------------------------------*/
static void do_sib(int m)
{
int s, i, b;
s = SCALE(sib());
i = INDEX(sib());
b = BASE(sib());
switch (b) { /* pick base */
case 0: ua_str("%p:[eax"); break;
case 1: ua_str("%p:[ecx"); break;
case 2: ua_str("%p:[edx"); break;
case 3: ua_str("%p:[ebx"); break;
case 4: ua_str("%p:[esp"); break;
case 5: if (m == 0) {
ua_str("%p:[");
//Flags already set
outhex('d', 4, 0, addrsize, 0);
} else {
ua_str("%p:[ebp");
}
break;
case 6: ua_str("%p:[esi"); break;
case 7: ua_str("%p:[edi"); break;
}
switch (i) { /* and index */
case 0: uprintf("+eax"); break;
case 1: uprintf("+ecx"); break;
case 2: uprintf("+edx"); break;
case 3: uprintf("+ebx"); break;
case 4: break;
case 5: uprintf("+ebp"); break;
case 6: uprintf("+esi"); break;
case 7: uprintf("+edi"); break;
}
if (i != 4)
switch (s) { /* and scale */
case 0: uprintf(""); break;
case 1: uprintf("*2"); break;
case 2: uprintf("*4"); break;
case 3: uprintf("*8"); break;
}
}
static void do_sib(int m)
{ int s, i, b;
s = SCALE(sib());
i = INDEX(sib());
b = BASE(sib());
switch(b) { /* Pick base */
case 0: ua_str("%p:[EAX"); break;
case 1: ua_str("%p:[ECX"); break;
case 2: ua_str("%p:[EDX"); break;
case 3: ua_str("%p:[EBX"); break;
case 4: ua_str("%p:[ESP"); break;
case 5:
if(m == 0) {
ua_str("%p:[");
outhex('d', 4, 0, addrsize, 0);
} else {
ua_str("%p:[EBP");
}
break;
case 6: ua_str("%p:[ESI"); break;
case 7: ua_str("%p:[EDI"); break;
}
switch(i) { /* and index */
case 0: uprintf("+EAX"); break;
case 1: uprintf("+ECX"); break;
case 2: uprintf("+EDX"); break;
case 3: uprintf("+EBX"); break;
case 4: break;
case 5: uprintf("+EBP"); break;
case 6: uprintf("+ESI"); break;
case 7: uprintf("+EDI"); break;
}
if(i != 4) {
switch(s) { /* and scale */
case 0: uprintf(""); break;
case 1: uprintf("*2"); break;
case 2: uprintf("*4"); break;
case 3: uprintf("*8"); break;
}
}
}
/* $e <- a^3$ */
static void gf33m_cubic(element_t e, element_t a) {
field_ptr base = BASE(a);
element_ptr a0 = GF33M(a)->_0, a1 = GF33M(a)->_1, a2 = GF33M(a)->_2, e0 =
GF33M(e)->_0, e1 = GF33M(e)->_1, e2 = GF33M(e)->_2;
element_t a03, a13, a23;
element_init(a03, base);
element_init(a13, base);
element_init(a23, base);
element_cubic(a03, a0);
element_cubic(a13, a1);
element_cubic(a23, a2);
element_add(a03, a03, a13);
element_add(a03, a03, a23);
element_ptr c0 = a03;
element_sub(a13, a13, a23);
element_ptr c1 = a13;
element_ptr c2 = a23;
element_set(e0, c0);
element_set(e1, c1);
element_set(e2, c2);
element_clear(a03);
element_clear(a13);
element_clear(a23);
}
void bubble_sort(void *base, size_t nelem, size_t width, FCMP fcmp)
{
int i, j, s;
void *t;
t = malloc(width);
for (i = 0; i < nelem-1; i++)
{
s = 0;
for (j = 1; j < nelem-i; j++)
{
if (fcmp(BASE(j-1), BASE(j)) > 0)
{
memcpy(t, BASE(j-1), width);
memcpy(BASE(j-1), BASE(j), width);
memcpy(BASE(j), t, width);
s = 1;
}
}
if (s == 0) break;
}
free(t);
}
void select_sort(void *base, size_t nelem, size_t width, FCMP fcmp)
{
void *min;
int minindex;
int i, j;
min = malloc(width);
for (i = 0; i < nelem - 1; i++)
{
minindex = i;
memcpy(min, BASE(i), width);
for (j = i + 1; j < nelem; j++)
{
if (fcmp(min, BASE(j)) > 0)
{
memcpy(min, BASE(j), width);
minindex = j;
}
}
memcpy(BASE(minindex), BASE(i), width);
memcpy(BASE(i), min, width);
}
free(min);
}
#include ELEM_GEMM_INC
#include ELEM_HERK_INC
#include ELEM_HERMITIANEIG_INC
#include ELEM_FROBENIUSNORM_INC
#include ELEM_MAXNORM_INC
// TODO: Use a relative-truncated HermitianEig for relative thresholding
namespace elem {
namespace svd {
template<typename F>
inline void
TallAbsoluteThresholded
( Matrix<F>& A, Matrix<BASE(F)>& s, Matrix<F>& V, BASE(F) tol=0 )
{
DEBUG_ONLY(
CallStackEntry cse("svd::TallAbsoluteThresholded");
if( A.Height() < A.Width() )
LogicError("A must be at least as tall as it is wide");
if( tol < 0 )
LogicError("negative threshold does not make sense");
)
typedef Base<F> Real;
const Int m = A.Height();
const Int n = A.Width();
const Real frobNorm = FrobeniusNorm( A );
if( tol == Real(0) )
{
const Real eps = lapack::MachineEpsilon<Real>();
virtual void ResizeTo( Int height, Int width );
virtual void ResizeTo( Int height, Int width, Int ldim );
// Distribution alignment
virtual void AlignWith( const elem::DistData& data );
virtual void AlignWith( const AbstractDistMatrix<T>& A );
virtual void AlignColsWith( const elem::DistData& data );
virtual void AlignColsWith( const AbstractDistMatrix<T>& A );
//
// Though the following routines are meant for complex data, all but two
// logically applies to real data.
//
virtual void SetRealPart( Int i, Int j, BASE(T) u );
// Only valid for complex data
virtual void SetImagPart( Int i, Int j, BASE(T) u );
virtual void UpdateRealPart( Int i, Int j, BASE(T) u );
// Only valid for complex data
virtual void UpdateImagPart( Int i, Int j, BASE(T) u );
//------------------------------------------------------------------------//
// Routines specific to [VC,* ] distribution //
//------------------------------------------------------------------------//
//
// Collective routines
//
void GetDiagonal( DistMatrix<T,VC,STAR>& d, Int offset=0 ) const;
// See Z. Bai, J. Demmel, J. Dongarra, A. Petitet, H. Robinson, and K. Stanley's
// "The spectral decomposition of nonsymmetric matrices on distributed memory
// parallel computers". Currently available at:
// www.netlib.org/lapack/lawnspdf/lawn91.pdf
namespace elem {
namespace schur {
//
// X = [B;A]
//
template<typename F>
inline int
InverseFreeSign( Matrix<F>& X, Int maxIts=100, BASE(F) tau=0 )
{
DEBUG_ONLY(CallStackEntry cse("schur::InverseFreeSign"))
typedef Base<F> Real;
const Int n = X.Width();
if( X.Height() != 2*n )
LogicError("X must be 2n x n");
// Compute the tolerance if it is unset
if( tau == Real(0) )
tau = n*lapack::MachineEpsilon<Real>();
// Expose A and B in the original and temporary
Matrix<F> XAlt( 2*n, n );
Matrix<F> A, B, AAlt, BAlt;
PartitionDown( X, B, A, n );
PartitionDown( XAlt, BAlt, AAlt, n );
