// -------------------------------------------------------------------
bool
PosixRegEx::execute(MatchArray &sub, const String &str,
size_t index, size_t count, int eflags)
{
if( !compiled)
{
BLOCXX_THROW(RegExCompileException,
"Regular expression is not compiled");
}
if( index > str.length())
{
BLOCXX_THROW(OutOfBoundsException,
Format("String index out of bounds ("
"length = %1, index = %2).",
str.length(), index
).c_str());
}
if( count == 0)
{
count = m_regex.re_nsub + 1;
}
AutoPtrVec<regmatch_t> rsub(new regmatch_t[count]);
rsub[0].rm_so = -1;
rsub[0].rm_eo = -1;
sub.clear();
m_ecode = ::regexec(&m_regex, str.c_str() + index,
count, rsub.get(), eflags);
if( m_ecode == REG_NOERROR)
{
m_error.erase();
if( m_flags & REG_NOSUB)
{
return true;
}
sub.resize(count);
for(size_t n = 0; n < count; n++)
{
if( rsub[n].rm_so < 0 || rsub[n].rm_eo < 0)
{
sub[n] = rsub[n];
}
else
{
rsub[n].rm_so += index;
rsub[n].rm_eo += index;
sub[n] = rsub[n];
}
}
return true;
}
else
{
m_error = getError(&m_regex, m_ecode);
return false;
}
}
int StackSub(void)
{
if(curstksize < 2){
return 1;
}
stack[0] = rsub(stack[1], stack[0]);
for(int i = 1; i < curstksize - 1; ++i){
stack[i] = stack[i + 1];
}
--curstksize;
return 0;
}
/**
@brief ハウスホルダー・ベクトルへの変換.
@details h[0]=0; ...; h[k-1]=0; h[k]=-s*xi; h[k+1]=x[k+1]; ...; h[n-1]=x[n-1];
@param[in] h 初期化済みのベクトル.サイズはn.
@param[in] x 初期化済みのベクトル.サイズはn.
@param[in] n ベクトルのサイズ.
@param[in] k 第k要素が基準.
@param[out] h ハウスホルダー・ベクトル.
*/
void rhouseholder_vec(int n, int k, rmulti **h, rmulti *alpha, rmulti **x)
{
int p0,p1,prec;
rmulti *eta=NULL,*zeta=NULL,*xi=NULL,*axk=NULL;
// allocate
p0=rget_prec(alpha);
p1=rvec_get_prec_max(n,h);
prec=MAX2(p0,p1);
eta=rallocate_prec(prec);
zeta=rallocate_prec(prec);
xi=rallocate_prec(prec);
axk=rallocate_prec(prec);
//----------- norm
rvec_sum_pow2(xi,n-k-1,&x[k+1]); // xi=sum(abs(x((k+1):end)).^2);
rmul(axk,x[k],x[k]); // axk=|x[k]|^2
radd(eta,axk,xi); // eta=|x[k]|^2+...
rsqrt(axk,axk); // axk=|x[k]|
rsqrt(eta,eta); // eta=sqrt(|x[k]|^2+...)
if(req_d(eta,0)){rsub(xi,eta,axk);} // xi=eta-|x(k)|
else{ // xi=xi/(|x(k)|+eta)
radd(zeta,axk,eta);
rdiv(xi,xi,zeta);
}
//----------- h
rvec_set_zeros(k,h);
rvec_copy(n-k-1,&h[k+1],&x[k+1]); // h((k+1):end)=x((k+1):end);
if(ris_zero(x[k])){
rcopy(h[k],xi); rneg(h[k],h[k]); // h[k]=-xi
}else{
rdiv(zeta,xi,axk); rneg(zeta,zeta); // zeta=-xi/axk;
rmul(h[k],x[k],zeta); // h[k]=zeta*x[k];
}
//----------- alpha
if(req_d(xi,0) || req_d(eta,0)){
rset_d(alpha,0);
}else{
rmul(alpha,xi,eta); // alpha=1/(xi*eta)
rinv(alpha,alpha);
}
// free
eta=rfree(eta);
zeta=rfree(zeta);
xi=rfree(xi);
axk=rfree(axk);
}
void riep_dhToda_TN(int m, int M, rmulti **A, int LDA, rmulti **Q, int LDQ, rmulti **E, rmulti **lambda, rmulti **c, int debug)
{
int prec=0,k=0,n=0,f_size=0,n_size=0,*Q0_size=NULL,*E0_size=NULL,LDQ1;
rmulti *a=NULL,**f=NULL,***Q0=NULL,***E0=NULL,**sigma=NULL,**Q1=NULL,**E1=NULL;
// init
n_size=(M+1)*(m-1)+2*M;
// precision
prec=rmat_get_prec_max(m,m,A,LDA);
// allocate
if(Q==NULL) {
LDQ1=m;
Q1=rmat_allocate_prec(m,M,prec);
}
else {
LDQ1=LDQ;
Q1=Q;
}
if(E==NULL) {
E1=rvec_allocate_prec(m,prec);
}
else {
E1=E;
}
sigma=rvec_allocate_prec(m,prec);
a=rallocate_prec(prec);
Q0_size=ivec_allocate(m);
Q0=malloc(m*sizeof(rmulti**));
for(k=0; k<m; k++) {
Q0_size[k]=n_size-k*(M+1);
Q0[k]=rvec_allocate_prec(Q0_size[k],prec);
}
E0_size=ivec_allocate(m);
E0=malloc(m*sizeof(rmulti**));
for(k=0; k<m; k++) {
E0_size[k]=n_size-(k+1)*(M+1)+1;
E0[k]=rvec_allocate_prec(E0_size[k],prec);
}
f_size=Q0_size[0]+1;
f=rvec_allocate_prec(f_size,prec);
// generate sigma[n]
rinv_d(a,M);
rvec_pow_r(m,sigma,lambda,a);
// generate f[n]
for(n=0; n<f_size; n++) {
rset_d(f[n],0);
for(k=0; k<m; k++) {
rpow_si(a,sigma[k],n); // a=(sigma[i])^n
radd_mul(f[n],c[k],a); // f[i]=f[i]+c[i]*(sigma[i])^n
}
}
// Q[n][0]=f[n+1]/f[n]
for(n=0; n<Q0_size[0]; n++) {
if(n+1<f_size) {
rdiv(Q0[0][n],f[n+1],f[n]);
}
else {
rset_nan(Q0[0][n]);
}
}
// E[0][n]=Q[0][n+M]-Q[0][n];
k=0;
for(n=0; n<E0_size[k]; n++) {
if(n+M<Q0_size[k] && n<Q0_size[k]) {
rsub(E0[k][n],Q0[k][n+M],Q0[k][n]);
}
else {
rset_nan(E0[k][n]);
}
}
// loop for QE-table
for(k=1; k<m; k++) {
// Q[k][n]=(E[k-1][n+1]*Q[k-1][n+M])/E[k-1][n];
for(n=0; n<Q0_size[k]; n++) {
rdiv(a,E0[k-1][n+1],E0[k-1][n]);
rmul(Q0[k][n],a,Q0[k-1][n+M]);
}
// E[k][n]=Q[k][n+M]-Q[k][n]+E[k-1][n+1]
for(n=0; n<E0_size[k]; n++) {
rsub(a,Q0[k][n+M],Q0[k][n]);
radd(E0[k][n],a,E0[k-1][n+1]);
}
}
// debug
if(debug>0) {
printf("Q=\n");
for(n=0; n<n_size; n++) {
for(k=0; k<m; k++) {
if(n<Q0_size[k]) {
mpfr_printf("%.3Re ",Q0[k][n]);
}
}
printf("\n");
}
printf("E=\n");
for(n=0; n<n_size; n++) {
for(k=0; k<m; k++) {
if(n<E0_size[k]) {
mpfr_printf("%.3Re ",E0[k][n]);
}
}
printf("\n");
}
}
// generate vector E
for(k=0; k<m; k++) {
rcopy(E1[k],E0[k][0]);
}
// generate matrix Q
for(n=0; n<M; n++) {
for(k=0; k<m; k++) {
rcopy(MAT(Q1,k,n,LDQ1),Q0[k][n]);
}
}
// genrate matrix A
if(A!=NULL) {
riep_dhToda_QE_to_A(m,M,A,LDA,Q1,LDQ1,E1,debug);
}
// done
if(Q==NULL) {
Q1=rmat_free(LDQ1,M,Q1);
}
else {
Q1=NULL;
}
if(E==NULL) {
E1=rvec_free(m,E1);
}
else {
E1=NULL;
}
a=rfree(a);
f=rvec_free(f_size,f);
sigma=rvec_free(m,sigma);
for(k=0; k<m; k++) {
Q0[k]=rvec_free(Q0_size[k],Q0[k]);
}
free(Q0);
Q0=NULL;
for(k=0; k<m; k++) {
E0[k]=rvec_free(E0_size[k],E0[k]);
}
free(E0);
E0=NULL;
Q0_size=ivec_free(Q0_size);
E0_size=ivec_free(E0_size);
return;
}
//Perform the operation given by the CPU
void ALU::operation(int code, Register a, Register b)
{
//Reset all flags that aren't required
m_flags[1] = 0;
m_flags[2] = 0;
m_flags[3] = 0;
//Check if unary operation
if(!(code==0||code==1||code==4||code==9||code==13||code==16||code==17||code==18||code==19||code==20))
{
//Compare a and b if possible and set flags
if(a.getValue()>b.getValue())
{
m_flags[1] = 1;
}
else if(a.getValue()==b.getValue())
{
m_flags[2] = 1;
}
}
//Perform operation based on code (sets carry flag to 0 if it isn't set in the operation)
if(code==0)
{
zero(a);
m_flags[0] = 0;
}
else if(code==1)
{
one(a);
m_flags[0] = 0;
}
else if(code==2)
{
add(a,b);
}
else if(code==3)
{
addc(a,b);
}
else if(code==4)
{
inc(a);
}
else if(code==5)
{
sub(a,b);
}
else if(code==6)
{
subc(a,b);
}
else if(code==7)
{
rsub(a,b);
}
else if(code==8)
{
rsubc(a,b);
}
else if(code==9)
{
dec(a);
}
else if(code==10)
{
mul(a,b);
}
else if(code==11)
{
random(a);
m_flags[0] = 0;
}
else if(code==16)
{
shl(a);
}
else if(code==17)
{
shlc(a);
}
else if(code==18)
{
shr(a);
}
else if(code==19)
{
shrc(a);
}
else if(code==20)
{
not(a);
m_flags[0] = 0;
}
else if(code==21)
{
and(a,b);
m_flags[0] = 0;
}
else if(code==22)
{
nand(a,b);
m_flags[0] = 0;
}
else if(code==23)
{
or(a,b);
m_flags[0] = 0;
}
else if(code==24)
{
nor(a,b);
m_flags[0] = 0;
}
else if(code==25)
{
xor(a,b);
m_flags[0] = 0;
}
else if(code==26)
{
xnor(a,b);
m_flags[0] = 0;
}
else if(code==27)
{
bclr(a,b);
m_flags[0] = 0;
}
else if(code==31)
{
m_flags[0] = 0;
}
//Check if output is 0 and set flag accordingly
if(a.getValue())
{
m_flags[3]=1;
}
}
