void ComputeGain(Geometry geo, Mode *ms, int Nh){
VecSet(geo->vH, 0.0);
Vecfun H, f;
CreateVecfun(&H, geo->vH);
CreateVecfun(&f, geo->vf);
int i, ih;
for(ih=0; ih<Nh; ih++){
Mode m = ms[ih];
double mc = get_c(m);
// do not change this from vscratch[3], or the hack below for single mode Column derivative will fail!
VecDotMedium(geo, m->vpsi, m->vpsi, geo->vscratch[3], geo->vMscratch[0]);
Vecfun psisq;
CreateVecfun(&psisq ,geo->vscratch[3]);
for(i=H.ns; i<H.ne; i++){
if(valr(&f, i) == 0.0) continue;
setr(&H, i, valr(&H, i) + sqr(mc) * valr(&psisq, i) ) ;
}
DestroyVecfun(&psisq);
}
if(geo->interference != 0.0 && Nh == 2){
// does not affect single mode case
VecDotMedium(geo, ms[0]->vpsi, ms[1]->vpsi, geo->vscratch[3], geo->vMscratch[0]);
Vec Ipsi = geo->vscratch[5];
TimesI( geo, ms[0]->vpsi, Ipsi);
VecDotMedium(geo, ms[1]->vpsi, Ipsi, geo->vscratch[6], geo->vMscratch[0]);
// 2 c1 c2 Re[ exp(i thet) psi1* x psi2) ]
// term in square bracket is (cos thet + i sin thet ) x
// ( E1R . E2R + E1I . E2I ) + i ( E1R . E2I - E1I . E2R )
// vscratch[3] and vscratch[6] are the real and imaginary parts of this last line
double costh = cos(geo->interference), sinth = sin(geo->interference);
VecScale(geo->vscratch[6], -sinth);
VecAXPY( geo->vscratch[6], costh, geo->vscratch[3]);
// now vscratch[6] = Re[ ... ]
double mc[2] = {get_c(ms[0]), get_c(ms[1]) };
Vecfun psi_int;
CreateVecfun(&psi_int ,geo->vscratch[6]);
for(i=H.ns; i<H.ne; i++){
if(valr(&f, i) == 0.0) continue;
setr(&H, i, valr(&H, i) + 2.0*mc[0]*mc[1] * valr(&psi_int, i) ) ;
}
DestroyVecfun(&psi_int);
}
for(i=H.ns; i<H.ne; i++)
setr(&H, i, 1.0 / (1.0 + valr(&H, i) ) );
// for plotting purposes, don't check if valr(&f, i)==0 here
DestroyVecfun(&H);
DestroyVecfun(&f);
}
int main(void)
{
int c;
readline();
while ((c = get_c()) != '\n') {
switch (c){
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
unget_c();
readn();
break;
case '+': case '-': /* 遇到加减法时,先读入下一组数字,再存入运算符号 */
readn();
pushstr(c);
break;
case '*': case '/': /* 遇到乘除法时,现把当前的预算符出栈,存入操作数,再存入乘除符号 */
pushtemp(popstr());
readn();
pushstr(c);
pushstr(poptemp()); /* 原先的预算符号进栈 */
default:
break;
}
}
/* 输出逆波兰数序 */
pushstr('\0');
printf("%s\n", str);
return 0;
}
void TensorDerivative(Mode m, Mode mj, Geometry geo, Vec df, Vec vpsibra, Vec vIpsi, int ih){
double mjc = get_c(mj);
dcomp mw = get_w(m), yw = gamma_w(m, geo) ;
Vecfun f, H, psibra;
CreateVecfun(&f, geo->vf);
CreateVecfun(&H, geo->vH);
CreateVecfun(&psibra, vpsibra);
Complexfun psi;
CreateComplexfun(&psi, m->vpsi, vIpsi);
int i;
for(i=f.ns; i<f.ne; i++){
if( valr(&f, i) == 0.0) continue;
dcomp ket_term = -csqr(mw ) * sqr(mjc) * 2.0
* sqr(valr(&H, i) ) * geo->D * valr(&f, i) * yw * valc(&psi, i);
double val = valr(&psibra, i) * (ir(geo, i)? cimag(ket_term) : creal(ket_term) );
VecSetValue(df, i+offset(geo, ih), val, INSERT_VALUES);
// df is assembled in SetJacobian
}
DestroyVecfun(&f);
DestroyVecfun(&H);
DestroyVecfun(&psibra);
DestroyComplexfun(&psi);
}
/* 读入一组数字,依次入栈，并且以逗号结尾*/
void readn(void) {
int c;
while ((c = get_c()) && c >= '0' && c <= '9')
pushstr(c);
pushstr(',');
unget_c();
}
void cstats_commit( cstats_t* csts, uint_t n_rds, uint_t n_wrs )
{
csts->t_waiting_raw += csts->wt_raw;
csts->t_waiting_war += csts->wt_war;
csts->t_waiting_waw += csts->wt_waw;
#ifdef TIMINGS
csts->t_commits += ( get_c() - csts->begin - csts->wt_raw - csts->wt_war - csts->wt_waw );
#endif
csts->wt_raw = 0;
csts->wt_war = 0;
csts->wt_waw = 0;
csts->n_reads += n_rds;
csts->n_writes += n_wrs;
csts->n_commits++;
//burceam: stats for Prof. Steffan to get num_reads and num_writes per committed transaction
//should not be left in, normally.
//fprintf (stderr, "%d %d\n", n_rds, n_wrs);
//fflush (stderr);
//burceam: end stats
}
pausescr()
{
comm_flush();
nl();
ansic(1);
put("[ Hit any key ]");
get_c();
put_char(12);
}
biquad::coefficients compute_linkwitz_riley_hipass_coefficients(double cutoff,
double sr) {
const auto c = get_c(cutoff, sr);
const auto a0 = c * c + c * sqrt(2) + 1;
return {(c * c) / a0,
(-2 * c * c) / a0,
(c * c) / a0,
(-2 * (c * c - 1)) / a0,
(c * c - c * sqrt(2) + 1) / a0};
}
void get_coefs(double *a, double *b, double *c)
{
*a = get_a() ;
*b = get_b() ;
*c = get_c() ;
}
void cstats_abort( cstats_t* csts, int invalidated, int reason )
{
csts->t_waiting_raw += csts->wt_raw;
csts->t_waiting_war += csts->wt_war;
csts->t_waiting_waw += csts->wt_waw;
unsigned long long abort_time = 0;
#ifdef TIMINGS
abort_time = ( get_c() - csts->begin - csts->wt_raw - csts->wt_war - csts->wt_waw );
csts->begin = get_c();
#endif
csts->wt_raw = 0;
csts->wt_war = 0;
csts->wt_waw = 0;
if( invalidated )
{
csts->n_invalidations++;
csts->t_invalidations += abort_time;
}
else
{
if( reason == 0 )
{
csts->n_deadlocks_raw++;
csts->t_deadlocks_raw += abort_time;
}
if( reason == 1 )
{
csts->n_deadlocks_war++;
csts->t_deadlocks_war += abort_time;
}
if( reason == 2 )
{
csts->n_deadlocks_waw++;
csts->t_deadlocks_waw += abort_time;
}
}
}
void ColumnDerivative(Mode m, Mode mj, Geometry geo, Vec dfR, Vec dfI, Vec vIpsi, Vec vpsisq, int ih){
// vIpsi is for m, vpsisq is for mj
// use pointers so can check whether ih = jh
// purposely don't set df = 0 here to allow multiple ih's
double mjc = get_c(mj);
dcomp mw = get_w(m), yw = gamma_w(m, geo);
Complexfun psi, eps;
CreateComplexfun(&psi,m->vpsi, vIpsi);
CreateComplexfun(&eps,geo->veps, geo->vIeps);
Vecfun f,H, psisq;
CreateVecfun(&f, geo->vf);
CreateVecfun(&H, geo->vH);
CreateVecfun(&psisq, vpsisq);
int i;
for(i=psi.ns; i<psi.ne; i++){
dcomp dfdk = 0.0, dfdc = 0.0,
DfywHpsi = geo->D * valr(&f, i) * yw * valr(&H, i) * valc(&psi, i);
if(m == mj)
dfdk += ( -csqr(mw)*yw / geo->y +2.0*mw ) * DfywHpsi + 2.0*mw* valc(&eps, i)*valc(&psi, i);
// note: adding dcomp to a double ignores the imaginary part
if(m->lasing && valr(&f, i) != 0.0){
// dHdk removed; field simply rescaled -DL 6/15/14
dfdc = csqr(mw) * DfywHpsi * valr(&H, i);
dfdc *= (-2.0*mjc)*valr(&psisq, i);
}
if( !m->lasing)
VecSetComplex(dfR, dfI, i+offset(geo, ih), ir(geo, i), dfdk, INSERT_VALUES);
else{
VecSetValue(dfR, i+offset(geo, ih), ir(geo, i)? cimag(dfdk) : creal(dfdk), INSERT_VALUES );
VecSetValue(dfI, i+offset(geo, ih), ir(geo, i)? cimag(dfdc) : creal(dfdc), INSERT_VALUES );
// df is assembled in SetJacobian
}
}
DestroyComplexfun(&eps);
DestroyComplexfun(&psi);
DestroyVecfun(&f);
DestroyVecfun(&H);
DestroyVecfun(&psisq);
}
void cai_tien()
{
get_t();
do
{
get_cd_ct();
get_c();
if (Tong > 5000) meo_vat();
get_d();
updatekt();
mumu();
} while (!Kt);
}
/* this performs the discrete transform */
CVC_trans discrete_transform(CVC *YPbPr)
{
CVC_trans pack_to_return;
pack_to_return.Pb = YPbPr->avg_Pb;
pack_to_return.Pr = YPbPr->avg_Pr;
pack_to_return.a = get_a(YPbPr);
pack_to_return.b = get_b(YPbPr);
pack_to_return.c = get_c(YPbPr);
pack_to_return.d = get_d(YPbPr);
return pack_to_return;
}
void* server_thread_run( void* arg )
{
int cycle;
unsigned long long now_0 = 0, now_1 = 0, now_2 = get_c();
server_thread_t* svt = (server_thread_t*) arg;
__tid = svt->tid;
thread_set_affinity( __tid );
thread_set_local_id( __tid );
log_info( "Starting workload...\n" );
for( cycle = 0; cycle < sv.wl_cycles && now_2 < sv.wl_stop; cycle++ )
{
server_thread_preprocess_workload( svt, cycle );
barrier_wait( &sv.barrier );
now_0 = get_c();
server_thread_process_workload( svt, cycle );
now_1 = get_c();
barrier_wait( &sv.barrier );
now_2 = get_c();
time_event( PROCESS, (now_1 - now_0) );
time_event( BARRIER, (now_2 - now_1) );
time_event( TOTAL, (now_2 - now_0) );
if( svt->tid == 0 )
server_thread_admin( cycle );
barrier_wait(&sv.barrier);
}
barrier_wait( &sv.barrier );
return 0;
}
//0 成功
//1 继续下一个
//-1 结束
int check_palindrome(char *a, char *b)
{
int len1 = strlen(a);
int len2 = strlen(b);
int last_index = get_last_index(len1, len2);
int i;
for (i = 0; i <= last_index; i++) {
int op_index = get_op_index(len1, len2, i);
char c1 = get_c(a, len1, b, i);
char c2 = get_c(a, len1, b, op_index);
if (c1 != c2) {
if (i >= len1 || i >= len2)
return 1;
if (c1 > c2)
return 1;
return -1;
// return 1;
}
}
return 0;
}
void get_s(char* s,int size)
{
int i=0;
while(i<size-1){
char cc=get_c();
if(cc!='\r'){
s[i++]=cc;
put_c(cc);
}
else
break;
}
s[i]='\0';
put_c('\n');
}
int scan_next()
{
lex_value = 0;
lex_type = NONE;
while( !is_done() )
{
char c = get_c();
switch( c )
{
case '\t':
case '\r':
case '\n':
case ' ':
break;
case '(':
case ')':
lex_type = c;
break;
case '*':
lex_type = CLOSURE;
break;
case '|':
lex_type = UNION;
break;
default:
lex_value = c;
lex_type = CONCAT;
}
if( lex_type != NONE )
{
return lex_type;
}
}
lex_type = DONE;
return DONE;
}
unsigned char get_hex()
{
unsigned char value = 0;
while(1){
unsigned char v;
v = get_c();
if (v >= '0' && v <= '9'){
put_c(v);
v -= 0x30;
value = (value << 4) | v;
}else if (v >= 'a' && v <= 'f'){
put_c(v);
v = v - 'a' + 10;
value = (value << 4) | v;
}else if (v == 0xd){
put_c(v);
return value;
}
}
}
int internal_get(struct DB *db, Block block, struct DBT *key)
{
int i = 0;
struct DBT key1, value1;
while (i < get_n(block)) {
get_data(block, i, &key1, &value1);
if (cmp(key, &key1) <= 0)
break;
i++;
}
if (i < get_n(block) && !cmp(key, &key1))
return i;
if (get_leaf(block))
return -1;
else {
int id = get_c(block, i);
db->block_read(db, block, id);
return internal_get(db, block, key);
}
return -1;
}
static int pade(double l)
{
int i, j;
double a[6];
double b[6];
a[1] = -a1;
a[2] = -a2;
a[3] = -a3;
a[4] = -a4;
a[5] = -a5;
b[0] = 1.0;
b[1] = a[1];
for (i = 2; i <= 5; i++) {
b[i] = 0.0;
for (j = 1; j <= i; j++)
b[i] += j * a[j] * b[i-j];
b[i] = b[i] / (double) i;
}
AA[0][0] = 1.0 - exp(a0 - l * sqrt(RG));
AA[0][1] = b[1];
AA[0][2] = b[2];
AA[0][3] = -b[3];
AA[1][0] = b[1];
AA[1][1] = b[2];
AA[1][2] = b[3];
AA[1][3] = -b[4];
AA[2][0] = b[2];
AA[2][1] = b[3];
AA[2][2] = b[4];
AA[2][3] = -b[5];
Gaussian_Elimination2(3);
ep3 = AA[0][3];
ep2 = AA[1][3];
ep1 = AA[2][3];
eq1 = ep1 + b[1];
eq2 = b[1] * ep1 + ep2 + b[2];
eq3 = ep3 * exp(a0 - l * sqrt(RG));
ep3 = ep3 / (tau*tau*tau);
ep2 = ep2 / (tau*tau);
ep1 = ep1 / tau;
eq3 = eq3 / (tau*tau*tau);
eq2 = eq2 / (tau*tau);
eq1 = eq1 / tau;
/*
printf("factor = %e\n", exp(-a0));
printf("ep1 = %e ep2 = %e ep3 = %e\n", ep1, ep2, ep3);
*/
exp_find_roots(ep1, ep2, ep3, &ex1, &ex2, &ex3);
/*
printf("roots are %e %e %e \n", ex1, ex2, ex3);
*/
ec1 = eval2(eq1 - ep1, eq2 - ep2, eq3 - ep3, ex1) /
eval2(3.0, 2.0 * ep1, ep2, ex1);
if (ifImg)
get_c(eq1 - ep1, eq2 - ep2, eq3 - ep3, ep1, ep2, ex2, ex3, &ec2, &ec3);
else {
ec2 = eval2(eq1 - ep1, eq2 - ep2, eq3 - ep3, ex2) /
eval2(3.0, 2.0 * ep1, ep2, ex2);
ec3 = eval2(eq1 - ep1, eq2 - ep2, eq3 - ep3, ex3) /
eval2(3.0, 2.0 * ep1, ep2, ex3);
}
return (1);
}
bool is_comment() const {
return get_c() == '/' && (get_linecnt() || end_col>col+1);
};
/*-------------------------------------------
| Name:parser
| Description:
| Parameters:
| Return Type:
| Comments:
| See:
---------------------------------------------*/
int parser(int fd_in,int fd,int fd_out,char * cmd){
signed char c;
int st=GET_SECTION;
char buf[32];
int i=0;
int pos= 0;
prm_t prm;
char * p =(char*)0;
int offset = 0;
if(cmd)
p = (char*)cmd;
lseek(fd_in,(off_t)0,SEEK_SET);
while((c = get_c(fd_in,&p))>0) {
if(c==' ')
continue;
if(c=='\x18')
break;
switch(st) {
case GET_SECTION:
if(c=='.') {
buf[i]='\0';
printf("%s.",buf);
if((pos = get_section(fd,buf,&fd_out,&offset))<0)
return -2; //cannot find section
st=GET_PRM;
i=0;
break;
}
if(c=='\r' || c=='\n')
break;
buf[i++]=c;
if(i==sizeof(buf))
return -1;
break;
case GET_PRM:
if(c=='=' || c==';' ||c=='\r' || c=='\n') {
buf[i]='\0';
printf("%s",buf);
if(get_prminfo(fd,pos,buf,&prm)<0)
return -3; //cannot find parameter in this section
if(fd_out<0)
return -1;
//
if(fd_out>=0)
if(lseek(fd_out,(off_t)(offset+prm.offset),SEEK_SET)<0)
return -1;
//
if(c=='=') {
st=SET_VALUE;
printf("=");
}else{
switch(prm.type) {
case 'c': {
char c=0;
read(fd_out,&c,prm.size);
printf("= %c\r\n",c);
}
break;
case 'd': {
int d=0;
int e;
e= read(fd_out,(char*)&d,prm.size);
printf("= %d\r\n",(int)d);
}
break;
case 'l': {
long l=0;
read(fd_out,(char*)&l,prm.size);
printf("= %ld\r\n",(long)l);
}
break;
case 'f': {
float f=0;
read(fd_out,(char*)&f,prm.size);
ftoa(buf,(float)f);
//printf(("= %f\r\n",f);
printf("= %s\r\n",buf);
}
break;
//-----------------------------------------------------------------------
case 's': { //modif AS du 07-07-2008
char c=0;
char count = prm.size;
if (count != 0) {
read(fd_out,&c,1);
printf("= %c",c);
count = count - 1;
while ((count != 0) && (c != 0) ) {
read(fd_out,&c,1);
printf("%c",c);
count = count - 1;
}
}
printf("\r\n");
}
break;
//-----------------------------------------------------------------------
default:
return -1;
break;
}
//printf(("get value: type:'%c' size:%d pos:%d\r\n>",prm.type,prm.size,prm.offset);
st=GET_SECTION;
if(!c)
return 0;
}
i=0;
buf[0]='\0';
break;
}
if(c=='\r' || c=='\n')
break;
buf[i++]=c;
if(i==sizeof(buf))
return -1;
break;
case SET_VALUE:
if(c==';' ||c=='\r' || c=='\n') {
buf[i]='\0';
printf("%s\r\n",buf);
switch(prm.type) {
case 'c':
write(fd_out,buf,prm.size);
break;
case 'd': {
int d = atoi(buf);
write(fd_out,(char*)&d,prm.size);
}
break;
case 'l': {
long l = atol(buf);
write(fd_out,(char*)&l,prm.size);
}
break;
case 'f': {
float f = (float)atof(buf);
write(fd_out,(char*)&f,prm.size);
}
break;
default:
return -1;
break;
}
//printf("\r\nset value: type:'%c' size:%d pos:%d value=%s\r\n",prm.type,prm.size,prm.offset,buf);
st = GET_SECTION;
i=0;
buf[0]='\0';
if(!c)
return 0;
break;
}
if(c=='\r' || c=='\n')
break;
buf[i++]=c;
if(i==sizeof(buf))
return -1;
break;
}
}
return 0;
}
void FeatureCoordinates::drawLine(cv::Mat& drawImg, const FeatureCoordinates& other, const cv::Scalar& color, int thickness) const{
cv::line(drawImg,get_c(),other.get_c(),color,thickness);
}
void FeatureCoordinates::drawText(cv::Mat& drawImg, const std::string& s, const cv::Scalar& color) const{
cv::putText(drawImg,s,get_c(),cv::FONT_HERSHEY_SIMPLEX, 0.4, color);
}
void FeatureCoordinates::drawEllipse(cv::Mat& drawImg, const cv::Scalar& color, double scaleFactor, const bool withCenterPoint) const{
if(withCenterPoint) drawPoint(drawImg,color);
cv::ellipse(drawImg,get_c(),cv::Size(std::max(static_cast<int>(scaleFactor*sigma1_+0.5),1),std::max(static_cast<int>(scaleFactor*sigma2_+0.5),1)),sigmaAngle_*180/M_PI,0,360,color,1,8,0);
}
int main()
{
float *arr = get_arr(); // [4, 3, 2, 1]
float *uarr = get_uarr(); // [5, 4, 3, 2]
float *arr2 = get_arr2(); // [4, 3, 2, 1]
float *uarr2 = get_uarr2(); // [5, 4, 3, 2]
__m128 a = get_a(); // [8, 6, 4, 2]
__m128 b = get_b(); // [1, 2, 3, 4]
// Check that test data is like expected.
Assert(((uintptr_t)arr & 0xF) == 0); // arr must be aligned by 16.
Assert(((uintptr_t)uarr & 0xF) != 0); // uarr must be unaligned.
Assert(((uintptr_t)arr2 & 0xF) == 0); // arr must be aligned by 16.
Assert(((uintptr_t)uarr2 & 0xF) != 0); // uarr must be unaligned.
// Test that aeq itself works and does not trivially return true on everything.
Assert(aeq_("",_mm_load_ps(arr), 4.f, 3.f, 2.f, 0.f, false) == false);
#ifdef TEST_M64
Assert(aeq64(u64castm64(0x22446688AACCEEFFULL), 0xABABABABABABABABULL, false) == false);
#endif
// SSE1 Load instructions:
aeq(_mm_load_ps(arr), 4.f, 3.f, 2.f, 1.f); // 4-wide load from aligned address.
aeq(_mm_load_ps1(uarr), 2.f, 2.f, 2.f, 2.f); // Load scalar from unaligned address and populate 4-wide.
aeq(_mm_load_ss(uarr), 0.f, 0.f, 0.f, 2.f); // Load scalar from unaligned address to lowest, and zero all highest.
aeq(_mm_load1_ps(uarr), 2.f, 2.f, 2.f, 2.f); // _mm_load1_ps == _mm_load_ps1
aeq(_mm_loadh_pi(a, (__m64*)uarr), 3.f, 2.f, 4.f, 2.f); // Load two highest addresses, preserve two lowest.
aeq(_mm_loadl_pi(a, (__m64*)uarr), 8.f, 6.f, 3.f, 2.f); // Load two lowest addresses, preserve two highest.
aeq(_mm_loadr_ps(arr), 1.f, 2.f, 3.f, 4.f); // 4-wide load from an aligned address, but reverse order.
aeq(_mm_loadu_ps(uarr), 5.f, 4.f, 3.f, 2.f); // 4-wide load from an unaligned address.
// SSE1 Set instructions:
aeq(_mm_set_ps(uarr[3], 2.f, 3.f, 4.f), 5.f, 2.f, 3.f, 4.f); // 4-wide set by specifying four immediate or memory operands.
aeq(_mm_set_ps1(uarr[3]), 5.f, 5.f, 5.f, 5.f); // 4-wide set by specifying one scalar that is expanded.
aeq(_mm_set_ss(uarr[3]), 0.f, 0.f, 0.f, 5.f); // Set scalar at lowest index, zero all higher.
aeq(_mm_set1_ps(uarr[3]), 5.f, 5.f, 5.f, 5.f); // _mm_set1_ps == _mm_set_ps1
aeq(_mm_setr_ps(uarr[3], 2.f, 3.f, 4.f), 4.f, 3.f, 2.f, 5.f); // 4-wide set by specifying four immediate or memory operands, but reverse order.
aeq(_mm_setzero_ps(), 0.f, 0.f, 0.f, 0.f); // Returns a new zero register.
// SSE1 Move instructions:
aeq(_mm_move_ss(a, b), 8.f, 6.f, 4.f, 4.f); // Copy three highest elements from a, and lowest from b.
aeq(_mm_movehl_ps(a, b), 8.f, 6.f, 1.f, 2.f); // Copy two highest elements from a, and take two highest from b and place them to the two lowest in output.
aeq(_mm_movelh_ps(a, b), 3.f, 4.f, 4.f, 2.f); // Copy two lowest elements from a, and take two lowest from b and place them to the two highest in output.
// SSE1 Store instructions:
#ifdef TEST_M64
/*M64*/*(uint64_t*)uarr = 0xCDCDCDCDCDCDCDCDULL; _mm_maskmove_si64(u64castm64(0x00EEDDCCBBAA9988ULL), u64castm64(0x0080FF7F01FEFF40ULL), (char*)uarr); Assert(*(uint64_t*)uarr == 0xCDEEDDCDCDAA99CDULL); // _mm_maskmove_si64: Conditionally store bytes of a 64-bit value.
/*M64*/*(uint64_t*)uarr = 0xABABABABABABABABULL; _m_maskmovq(u64castm64(0x00EEDDCCBBAA9988ULL), u64castm64(0x0080FF7F01FEFF40ULL), (char*)uarr); Assert(*(uint64_t*)uarr == 0xABEEDDABABAA99ABULL); // _m_maskmovq is an alias to _mm_maskmove_si64.
#endif
_mm_store_ps(arr2, a); aeq(_mm_load_ps(arr2), 8.f, 6.f, 4.f, 2.f); // _mm_store_ps: 4-wide store to aligned memory address.
_mm_store_ps1(arr2, a); aeq(_mm_load_ps(arr2), 2.f, 2.f, 2.f, 2.f); // _mm_store_ps1: Store lowest scalar to aligned address, duplicating the element 4 times.
_mm_storeu_ps(uarr2, _mm_set1_ps(100.f)); _mm_store_ss(uarr2, b); aeq(_mm_loadu_ps(uarr2), 100.f, 100.f, 100.f, 4.f); // _mm_store_ss: Store lowest scalar to unaligned address. Don't adjust higher addresses in memory.
_mm_store_ps(arr2, _mm_set1_ps(100.f)); _mm_store1_ps(arr2, a); aeq(_mm_load_ps(arr2), 2.f, 2.f, 2.f, 2.f); // _mm_store1_ps == _mm_store_ps1
_mm_storeu_ps(uarr2, _mm_set1_ps(100.f)); _mm_storeh_pi((__m64*)uarr2, a); aeq(_mm_loadu_ps(uarr2), 100.f, 100.f, 8.f, 6.f); // _mm_storeh_pi: Store two highest elements to memory.
_mm_storeu_ps(uarr2, _mm_set1_ps(100.f)); _mm_storel_pi((__m64*)uarr2, a); aeq(_mm_loadu_ps(uarr2), 100.f, 100.f, 4.f, 2.f); // _mm_storel_pi: Store two lowest elements to memory.
_mm_storer_ps(arr2, a); aeq(_mm_load_ps(arr2), 2.f, 4.f, 6.f, 8.f); // _mm_storer_ps: 4-wide store to aligned memory address, but reverse the elements on output.
_mm_storeu_ps(uarr2, a); aeq(_mm_loadu_ps(uarr2), 8.f, 6.f, 4.f, 2.f); // _mm_storeu_ps: 4-wide store to unaligned memory address.
#ifdef TEST_M64
/*M64*/_mm_stream_pi((__m64*)uarr, u64castm64(0x0080FF7F01FEFF40ULL)); Assert(*(uint64_t*)uarr == 0x0080FF7F01FEFF40ULL); // _mm_stream_pi: 2-wide store, but with a non-temporal memory cache hint.
#endif
_mm_store_ps(arr2, _mm_set1_ps(100.f)); _mm_stream_ps(arr2, a); aeq(_mm_load_ps(arr2), 8.f, 6.f, 4.f, 2.f); // _mm_stream_ps: 4-wide store, but with a non-temporal memory cache hint.
// SSE1 Arithmetic instructions:
aeq(_mm_add_ps(a, b), 9.f, 8.f, 7.f, 6.f); // 4-wide add.
aeq(_mm_add_ss(a, b), 8.f, 6.f, 4.f, 6.f); // Add lowest element, preserve three highest unchanged from a.
aeq(_mm_div_ps(a, _mm_set_ps(2.f, 3.f, 8.f, 2.f)), 4.f, 2.f, 0.5f, 1.f); // 4-wide div.
aeq(_mm_div_ss(a, _mm_set_ps(2.f, 3.f, 8.f, 8.f)), 8.f, 6.f, 4.f, 0.25f); // Div lowest element, preserve three highest unchanged from a.
aeq(_mm_mul_ps(a, b), 8.f, 12.f, 12.f, 8.f); // 4-wide mul.
aeq(_mm_mul_ss(a, b), 8.f, 6.f, 4.f, 8.f); // Mul lowest element, preserve three highest unchanged from a.
#ifdef TEST_M64
__m64 m1 = get_m1();
/*M64*/aeq64(_mm_mulhi_pu16(m1, u64castm64(0x22446688AACCEEFFULL)), 0x002233440B4C33CFULL); // Multiply u16 channels, and store high parts.
/*M64*/aeq64( _m_pmulhuw(m1, u64castm64(0x22446688AACCEEFFULL)), 0x002233440B4C33CFULL); // _m_pmulhuw is an alias to _mm_mulhi_pu16.
__m64 m2 = get_m2();
/*M64*/aeq64(_mm_sad_pu8(m1, m2), 0x368ULL); // Compute abs. differences of u8 channels, and sum those up to a single 16-bit scalar.
/*M64*/aeq64( _m_psadbw(m1, m2), 0x368ULL); // _m_psadbw is an alias to _mm_sad_pu8.
#endif
aeq(_mm_sub_ps(a, b), 7.f, 4.f, 1.f, -2.f); // 4-wide sub.
aeq(_mm_sub_ss(a, b), 8.f, 6.f, 4.f, -2.f); // Sub lowest element, preserve three highest unchanged from a.
// SSE1 Elementary Math functions:
#ifndef __EMSCRIPTEN__ // TODO: Enable support for this to pass.
aeq(_mm_rcp_ps(a), 0.124969f, 0.166626f, 0.249939f, 0.499878f); // Compute 4-wide 1/x.
aeq(_mm_rcp_ss(a), 8.f, 6.f, 4.f, 0.499878f); // Compute 1/x of lowest element, pass higher elements unchanged.
aeq(_mm_rsqrt_ps(a), 0.353455f, 0.408203f, 0.499878f, 0.706909f); // Compute 4-wide 1/sqrt(x).
aeq(_mm_rsqrt_ss(a), 8.f, 6.f, 4.f, 0.706909f); // Compute 1/sqrt(x) of lowest element, pass higher elements unchanged.
#endif
aeq(_mm_sqrt_ps(a), 2.82843f, 2.44949f, 2.f, 1.41421f); // Compute 4-wide sqrt(x).
aeq(_mm_sqrt_ss(a), 8.f, 6.f, 4.f, 1.41421f); // Compute sqrt(x) of lowest element, pass higher elements unchanged.
__m128 i1 = get_i1();
__m128 i2 = get_i2();
// SSE1 Logical instructions:
#ifndef __EMSCRIPTEN__ // TODO: The polyfill currently does NaN canonicalization and breaks these.
aeqi(_mm_and_ps(i1, i2), 0x83200100, 0x0fecc988, 0x80244021, 0x13458a88); // 4-wide binary AND
aeqi(_mm_andnot_ps(i1, i2), 0x388a9888, 0xf0021444, 0x7000289c, 0x00121046); // 4-wide binary (!i1) & i2
aeqi(_mm_or_ps(i1, i2), 0xbfefdba9, 0xffefdfed, 0xf7656bbd, 0xffffdbef); // 4-wide binary OR
aeqi(_mm_xor_ps(i1, i2), 0x3ccfdaa9, 0xf0031665, 0x77412b9c, 0xecba5167); // 4-wide binary XOR
#endif
// SSE1 Compare instructions:
// a = [8, 6, 4, 2], b = [1, 2, 3, 4]
aeqi(_mm_cmpeq_ps(a, _mm_set_ps(8.f, 0.f, 4.f, 0.f)), 0xFFFFFFFF, 0, 0xFFFFFFFF, 0); // 4-wide cmp ==
aeqi(_mm_cmpeq_ss(a, _mm_set_ps(8.f, 0.f, 4.f, 2.f)), fcastu(8.f), fcastu(6.f), fcastu(4.f), 0xFFFFFFFF); // scalar cmp ==, pass three highest unchanged.
aeqi(_mm_cmpge_ps(a, _mm_set_ps(8.f, 7.f, 3.f, 5.f)), 0xFFFFFFFF, 0, 0xFFFFFFFF, 0); // 4-wide cmp >=
aeqi(_mm_cmpge_ss(a, _mm_set_ps(8.f, 7.f, 3.f, 0.f)), fcastu(8.f), fcastu(6.f), fcastu(4.f), 0xFFFFFFFF); // scalar cmp >=, pass three highest unchanged.
aeqi(_mm_cmpgt_ps(a, _mm_set_ps(8.f, 7.f, 3.f, 5.f)), 0, 0, 0xFFFFFFFF, 0); // 4-wide cmp >
aeqi(_mm_cmpgt_ss(a, _mm_set_ps(8.f, 7.f, 3.f, 2.f)), fcastu(8.f), fcastu(6.f), fcastu(4.f), 0); // scalar cmp >, pass three highest unchanged.
aeqi(_mm_cmple_ps(a, _mm_set_ps(8.f, 7.f, 3.f, 5.f)), 0xFFFFFFFF, 0xFFFFFFFF, 0, 0xFFFFFFFF); // 4-wide cmp <=
aeqi(_mm_cmple_ss(a, _mm_set_ps(8.f, 7.f, 3.f, 0.f)), fcastu(8.f), fcastu(6.f), fcastu(4.f), 0); // scalar cmp <=, pass three highest unchanged.
aeqi(_mm_cmplt_ps(a, _mm_set_ps(8.f, 7.f, 3.f, 5.f)), 0, 0xFFFFFFFF, 0, 0xFFFFFFFF); // 4-wide cmp <
aeqi(_mm_cmplt_ss(a, _mm_set_ps(8.f, 7.f, 3.f, 2.f)), fcastu(8.f), fcastu(6.f), fcastu(4.f), 0); // scalar cmp <, pass three highest unchanged.
aeqi(_mm_cmpneq_ps(a, _mm_set_ps(8.f, 0.f, 4.f, 0.f)), 0, 0xFFFFFFFF, 0, 0xFFFFFFFF); // 4-wide cmp !=
aeqi(_mm_cmpneq_ss(a, _mm_set_ps(8.f, 0.f, 4.f, 2.f)), fcastu(8.f), fcastu(6.f), fcastu(4.f), 0); // scalar cmp !=, pass three highest unchanged.
aeqi(_mm_cmpnge_ps(a, _mm_set_ps(8.f, 7.f, 3.f, 5.f)), 0, 0xFFFFFFFF, 0, 0xFFFFFFFF); // 4-wide cmp not >=
aeqi(_mm_cmpnge_ss(a, _mm_set_ps(8.f, 7.f, 3.f, 0.f)), fcastu(8.f), fcastu(6.f), fcastu(4.f), 0); // scalar cmp not >=, pass three highest unchanged.
aeqi(_mm_cmpngt_ps(a, _mm_set_ps(8.f, 7.f, 3.f, 5.f)), 0xFFFFFFFF, 0xFFFFFFFF, 0, 0xFFFFFFFF); // 4-wide cmp not >
aeqi(_mm_cmpngt_ss(a, _mm_set_ps(8.f, 7.f, 3.f, 2.f)), fcastu(8.f), fcastu(6.f), fcastu(4.f), 0xFFFFFFFF); // scalar cmp not >, pass three highest unchanged.
aeqi(_mm_cmpnle_ps(a, _mm_set_ps(8.f, 7.f, 3.f, 5.f)), 0, 0, 0xFFFFFFFF, 0); // 4-wide cmp not <=
aeqi(_mm_cmpnle_ss(a, _mm_set_ps(8.f, 7.f, 3.f, 0.f)), fcastu(8.f), fcastu(6.f), fcastu(4.f), 0xFFFFFFFF); // scalar cmp not <=, pass three highest unchanged.
aeqi(_mm_cmpnlt_ps(a, _mm_set_ps(8.f, 7.f, 3.f, 5.f)), 0xFFFFFFFF, 0, 0xFFFFFFFF, 0); // 4-wide cmp not <
aeqi(_mm_cmpnlt_ss(a, _mm_set_ps(8.f, 7.f, 3.f, 2.f)), fcastu(8.f), fcastu(6.f), fcastu(4.f), 0xFFFFFFFF); // scalar cmp not <, pass three highest unchanged.
__m128 nan1 = get_nan1(); // [NAN, 0, 0, NAN]
__m128 nan2 = get_nan2(); // [NAN, NAN, 0, 0]
aeqi(_mm_cmpord_ps(nan1, nan2), 0, 0, 0xFFFFFFFF, 0); // 4-wide test if both operands are not nan.
aeqi(_mm_cmpord_ss(nan1, nan2), fcastu(NAN), 0, 0, 0); // scalar test if both operands are not nan, pass three highest unchanged.
// Intel Intrinsics Guide documentation is wrong on _mm_cmpunord_ps and _mm_cmpunord_ss. MSDN is right: http://msdn.microsoft.com/en-us/library/khy6fk1t(v=vs.90).aspx
aeqi(_mm_cmpunord_ps(nan1, nan2), 0xFFFFFFFF, 0xFFFFFFFF, 0, 0xFFFFFFFF); // 4-wide test if one of the operands is nan.
#ifndef __EMSCRIPTEN__ // TODO: The polyfill currently does NaN canonicalization and breaks these.
aeqi(_mm_cmpunord_ss(nan1, nan2), fcastu(NAN), 0, 0, 0xFFFFFFFF); // scalar test if one of the operands is nan, pass three highest unchanged.
#endif
Assert(_mm_comieq_ss(a, b) == 0); Assert(_mm_comieq_ss(a, a) == 1); // Scalar cmp == of lowest element, return int.
Assert(_mm_comige_ss(a, b) == 0); Assert(_mm_comige_ss(a, a) == 1); // Scalar cmp >= of lowest element, return int.
Assert(_mm_comigt_ss(b, a) == 1); Assert(_mm_comigt_ss(a, a) == 0); // Scalar cmp > of lowest element, return int.
Assert(_mm_comile_ss(b, a) == 0); Assert(_mm_comile_ss(a, a) == 1); // Scalar cmp <= of lowest element, return int.
Assert(_mm_comilt_ss(a, b) == 1); Assert(_mm_comilt_ss(a, a) == 0); // Scalar cmp < of lowest element, return int.
Assert(_mm_comineq_ss(a, b) == 1); Assert(_mm_comineq_ss(a, a) == 0); // Scalar cmp != of lowest element, return int.
// The ucomi versions are identical to comi, except that ucomi signal a FP exception only if one of the input operands is a SNaN, whereas the comi versions signal a FP
// exception when one of the input operands is either a QNaN or a SNaN.
#ifndef __EMSCRIPTEN__ // TODO: Fix ucomi support in SSE to treat NaNs properly.
Assert(_mm_ucomieq_ss(a, b) == 0); Assert(_mm_ucomieq_ss(a, a) == 1); Assert(_mm_ucomieq_ss(a, nan1) == 1);
#endif
Assert(_mm_ucomige_ss(a, b) == 0); Assert(_mm_ucomige_ss(a, a) == 1); Assert(_mm_ucomige_ss(a, nan1) == 0);
Assert(_mm_ucomigt_ss(b, a) == 1); Assert(_mm_ucomigt_ss(a, a) == 0); Assert(_mm_ucomigt_ss(a, nan1) == 0);
Assert(_mm_ucomile_ss(b, a) == 0); Assert(_mm_ucomile_ss(a, a) == 1); Assert(_mm_ucomile_ss(a, nan1) == 1);
Assert(_mm_ucomilt_ss(a, b) == 1); Assert(_mm_ucomilt_ss(a, a) == 0); Assert(_mm_ucomilt_ss(a, nan1) == 1);
#ifndef __EMSCRIPTEN__ // TODO: Fix ucomi support in SSE to treat NaNs properly.
Assert(_mm_ucomineq_ss(a, b) == 1); Assert(_mm_ucomineq_ss(a, a) == 0); Assert(_mm_ucomineq_ss(a, nan1) == 0);
#endif
// SSE1 Convert instructions:
__m128 c = get_c(); // [1.5, 2.5, 3.5, 4.5]
__m128 e = get_e(); // [INF, -INF, 2.5, 3.5]
__m128 f = get_f(); // [-1.5, 1.5, -2.5, -9223372036854775808]
#ifdef TEST_M64
/*M64*/aeq(_mm_cvt_pi2ps(a, m2), 8.f, 6.f, -19088744.f, 1985229312.f); // 2-way int32 to float conversion to two lowest channels of m128.
/*M64*/aeq64(_mm_cvt_ps2pi(c), 0x400000004ULL); // 2-way two lowest floats from m128 to integer, return as m64.
#endif
aeq(_mm_cvtsi32_ss(c, -16777215), 1.5f, 2.5f, 3.5f, -16777215.f); // Convert int to float, store in lowest channel of m128.
aeq( _mm_cvt_si2ss(c, -16777215), 1.5f, 2.5f, 3.5f, -16777215.f); // _mm_cvt_si2ss is an alias to _mm_cvtsi32_ss.
#ifndef __EMSCRIPTEN__ // TODO: Fix banker's rounding in cvt functions.
Assert(_mm_cvtss_si32(c) == 4); Assert(_mm_cvtss_si32(e) == 4); // Convert lowest channel of m128 from float to int.
Assert( _mm_cvt_ss2si(c) == 4); Assert( _mm_cvt_ss2si(e) == 4); // _mm_cvt_ss2si is an alias to _mm_cvtss_si32.
#endif
#ifdef TEST_M64
/*M64*/aeq(_mm_cvtpi16_ps(m1), 255.f , -32767.f, 4336.f, 14207.f); // 4-way convert int16s to floats, return in a m128.
/*M64*/aeq(_mm_cvtpi32_ps(a, m1), 8.f, 6.f, 16744449.f, 284178304.f); // 2-way convert int32s to floats, return in two lowest channels of m128, pass two highest unchanged.
/*M64*/aeq(_mm_cvtpi32x2_ps(m1, m2), -19088744.f, 1985229312.f, 16744449.f, 284178304.f); // 4-way convert int32s from two different m64s to float.
/*M64*/aeq(_mm_cvtpi8_ps(m1), 16.f, -16.f, 55.f, 127.f); // 4-way convert int8s from lowest end of m64 to float in a m128.
/*M64*/aeq64(_mm_cvtps_pi16(c), 0x0002000200040004ULL); // 4-way convert floats to int16s in a m64.
/*M64*/aeq64(_mm_cvtps_pi32(c), 0x0000000400000004ULL); // 2-way convert two lowest floats to int32s in a m64.
/*M64*/aeq64(_mm_cvtps_pi8(c), 0x0000000002020404ULL); // 4-way convert floats to int8s in a m64, zero higher half of the returned m64.
/*M64*/aeq(_mm_cvtpu16_ps(m1), 255.f , 32769.f, 4336.f, 14207.f); // 4-way convert uint16s to floats, return in a m128.
/*M64*/aeq(_mm_cvtpu8_ps(m1), 16.f, 240.f, 55.f, 127.f); // 4-way convert uint8s from lowest end of m64 to float in a m128.
#endif
aeq(_mm_cvtsi64_ss(c, -9223372036854775808ULL), 1.5f, 2.5f, 3.5f, -9223372036854775808.f); // Convert single int64 to float, store in lowest channel of m128, and pass three higher channel unchanged.
Assert(_mm_cvtss_f32(c) == 4.5f); // Extract lowest channel of m128 to a plain old float.
Assert(_mm_cvtss_si64(f) == -9223372036854775808ULL); // Convert lowest channel of m128 from float to int64.
#ifdef TEST_M64
/*M64*/aeq64(_mm_cvtt_ps2pi(e), 0x0000000200000003ULL); aeq64(_mm_cvtt_ps2pi(f), 0xfffffffe80000000ULL); // Truncating conversion from two lowest floats of m128 to int32s, return in a m64.
#endif
Assert(_mm_cvttss_si32(e) == 3); // Truncating conversion from the lowest float of a m128 to int32.
Assert( _mm_cvtt_ss2si(e) == 3); // _mm_cvtt_ss2si is an alias to _mm_cvttss_si32.
#ifdef TEST_M64
/*M64*/aeq64(_mm_cvttps_pi32(c), 0x0000000300000004ULL); // Truncating conversion from two lowest floats of m128 to m64.
#endif
Assert(_mm_cvttss_si64(f) == -9223372036854775808ULL); // Truncating conversion from lowest channel of m128 from float to int64.
#ifndef __EMSCRIPTEN__ // TODO: Not implemented.
// SSE1 General support:
unsigned int mask = _MM_GET_EXCEPTION_MASK();
_MM_SET_EXCEPTION_MASK(mask);
unsigned int flushZeroMode = _MM_GET_FLUSH_ZERO_MODE();
_MM_SET_FLUSH_ZERO_MODE(flushZeroMode);
unsigned int roundingMode = _MM_GET_ROUNDING_MODE();
_MM_SET_ROUNDING_MODE(roundingMode);
unsigned int csr = _mm_getcsr();
_mm_setcsr(csr);
unsigned char dummyData[4096];
_mm_prefetch(dummyData, _MM_HINT_T0);
_mm_prefetch(dummyData, _MM_HINT_T1);
_mm_prefetch(dummyData, _MM_HINT_T2);
_mm_prefetch(dummyData, _MM_HINT_NTA);
_mm_sfence();
#endif
// SSE1 Misc instructions:
#ifdef TEST_M64
/*M64*/Assert(_mm_movemask_pi8(m1) == 100); // Return int with eight lowest bits set depending on the highest bits of the 8 uint8 input channels of the m64.
/*M64*/Assert( _m_pmovmskb(m1) == 100); // _m_pmovmskb is an alias to _mm_movemask_pi8.
#endif
Assert(_mm_movemask_ps(_mm_set_ps(-1.f, 0.f, 1.f, NAN)) == 8); Assert(_mm_movemask_ps(_mm_set_ps(-INFINITY, -0.f, INFINITY, -INFINITY)) == 13); // Return int with four lowest bits set depending on the highest bits of the 4 m128 input channels.
// SSE1 Probability/Statistics instructions:
#ifdef TEST_M64
/*M64*/aeq64(_mm_avg_pu16(m1, m2), 0x7FEE9D4D43A234C8ULL); // 4-way average uint16s.
/*M64*/aeq64( _m_pavgw(m1, m2), 0x7FEE9D4D43A234C8ULL); // _m_pavgw is an alias to _mm_avg_pu16.
/*M64*/aeq64(_mm_avg_pu8(m1, m2), 0x7FEE9D4D43A23548ULL); // 8-way average uint8s.
/*M64*/aeq64( _m_pavgb(m1, m2), 0x7FEE9D4D43A23548ULL); // _m_pavgb is an alias to _mm_avg_pu8.
// SSE1 Special Math instructions:
/*M64*/aeq64(_mm_max_pi16(m1, m2), 0xFFBA987654377FULL); // 4-way average uint16s.
/*M64*/aeq64( _m_pmaxsw(m1, m2), 0xFFBA987654377FULL); // _m_pmaxsw is an alias to _mm_max_pi16.
/*M64*/aeq64(_mm_max_pu8(m1, m2), 0xFEFFBA9876F0377FULL); // 4-way average uint16s.
/*M64*/aeq64( _m_pmaxub(m1, m2), 0xFEFFBA9876F0377FULL); // _m_pmaxub is an alias to _mm_max_pu8.
/*M64*/aeq64(_mm_min_pi16(m1, m2), 0xFEDC800110F03210ULL); // 4-way average uint16s.
/*M64*/aeq64( _m_pminsw(m1, m2), 0xFEDC800110F03210ULL); // is an alias to _mm_min_pi16.
/*M64*/aeq64(_mm_min_pu8(m1, m2), 0xDC800110543210ULL); // 4-way average uint16s.
/*M64*/aeq64( _m_pminub(m1, m2), 0xDC800110543210ULL); // is an alias to _mm_min_pu8.
#endif
// a = [8, 6, 4, 2], b = [1, 2, 3, 4]
aeq(_mm_max_ps(a, b), 8.f, 6.f, 4.f, 4.f); // 4-wide max.
aeq(_mm_max_ss(a, _mm_set1_ps(100.f)), 8.f, 6.f, 4.f, 100.f); // Scalar max, pass three highest unchanged.
aeq(_mm_min_ps(a, b), 1.f, 2.f, 3.f, 2.f); // 4-wide min.
aeq(_mm_min_ss(a, _mm_set1_ps(-100.f)), 8.f, 6.f, 4.f, -100.f); // Scalar min, pass three highest unchanged.
// SSE1 Swizzle instructions:
#ifdef TEST_M64
/*M64*/Assert(_mm_extract_pi16(m1, 1) == 4336); // Extract the given int16 channel from a m64.
/*M64*/Assert( _m_pextrw(m1, 1) == 4336); // _m_pextrw is an alias to _mm_extract_pi16.
/*M64*/aeq64(_mm_insert_pi16(m1, 0xABCD, 1), 0xFF8001ABCD377FULL); // Insert a int16 to a specific channel of a m64.
/*M64*/aeq64( _m_pinsrw(m1, 0xABCD, 1), 0xFF8001ABCD377FULL); // _m_pinsrw is an alias to _mm_insert_pi16.
/*M64*/aeq64(_mm_shuffle_pi16(m1, _MM_SHUFFLE(1, 0, 3, 2)), 0x10F0377F00FF8001ULL); // Shuffle int16s around in the 4 channels of the m64.
/*M64*/aeq64( _m_pshufw(m1, _MM_SHUFFLE(1, 0, 3, 2)), 0x10F0377F00FF8001ULL); // _m_pshufw is an alias to _mm_shuffle_pi16.
#endif
aeq(_mm_shuffle_ps(a, b, _MM_SHUFFLE(1, 0, 3, 2)), 3.f, 4.f, 8.f, 6.f);
aeq(_mm_unpackhi_ps(a, b), 1.f , 8.f, 2.f, 6.f);
aeq(_mm_unpacklo_ps(a, b), 3.f , 4.f, 4.f, 2.f);
// Transposing a matrix via the xmmintrin.h-provided intrinsic.
__m128 c0 = a; // [8, 6, 4, 2]
__m128 c1 = b; // [1, 2, 3, 4]
__m128 c2 = get_c(); // [1.5, 2.5, 3.5, 4.5]
__m128 c3 = get_d(); // [8.5, 6.5, 4.5, 2.5]
_MM_TRANSPOSE4_PS(c0, c1, c2, c3);
aeq(c0, 2.5f, 4.5f, 4.f, 2.f);
aeq(c1, 4.5f, 3.5f, 3.f, 4.f);
aeq(c2, 6.5f, 2.5f, 2.f, 6.f);
aeq(c3, 8.5f, 1.5f, 1.f, 8.f);
// All done!
if (numFailures == 0)
printf("Success!\n");
else
printf("%d tests failed!\n", numFailures);
}
void shape_cd::draw ( draw_vars& dr, stack&, QGraphicsScene& sc)
{
shapes* prev = get_prev();
if(prev && prev->type()== QString("shape_e") && dr.drawAsHorisontal())
{
return;
}
if ( is_current() ) dr.draw_marker ( sc );
int nSegments = get_n_segment();
for ( int i = 0 ; i < nSegments; ++i )
{
draw_point p_start = dr.get_p_otn(); //Начальная точка сегмента дуги.
draw_point delta_p = get_delta_p ( i ) * dr.get_masht() ;
qreal C = abs ( get_c ( i ) ); //Значение параметра кривизны.
qreal C_sign = get_c ( i ) / C; //Знак параметра кривизны.
dr.move_coords ( delta_p );
draw_point p_end = dr.get_p_otn(); //Конечная точка сегмента дуги.
if (dr.drawWhisOutPenUpMovement() && !dr.get_pero()) ;
else if ( get_c ( i ) != 0 )
{
qreal D = p_start.dist ( p_end ); //Расстояние между конечными точками сегмента.
qreal H = C * D / qreal ( 2 ) / qreal ( 127 ); //Высота сегмента.
qreal R = D * D / ( H * qreal ( 8 ) ) + H / qreal ( 2 ); //Радиус дуги.
qreal ang = p_start.agnle ( p_end );
draw_point p_mid_hord = p_start.polar ( ang, D / qreal ( 2 ) );
draw_point p_center = p_mid_hord.polar ( ang + C_sign * M_PI / qreal ( 2 ), R - H );
draw_point p_radius ( R, R );
qreal ang_start = draw_point::rtd ( p_center.agnle ( p_start ) );
qreal ang_4 = draw_point::rtd ( atan2 ( H, D / qreal ( 2 ) ) );
qreal ang_number = C_sign * ang_4 * qreal ( 4 );
if ( is_current() )
{
QPen pen( QBrush
( QColor ( draw_vars::s_color_cur ), Qt::SolidPattern ),
qreal ( draw_vars::s_width_cur ) ,
Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin );
pen.setCosmetic ( true );
if ( i == get_current())
pen.setColor(QColor ( draw_vars::s_color_9d));
else
pen.setColor(QColor ( draw_vars::s_color_cur));
{
QPainterPath path;
path.arcMoveTo ( p_center.x - p_radius.x , p_center.y - p_radius.y , p_radius.x * 2, p_radius.y * 2, -ang_start );
path.arcTo ( p_center.x - p_radius.x , p_center.y - p_radius.y , p_radius.x * 2, p_radius.y * 2, -ang_start , -ang_number );
QGraphicsPathItem *pathItem = new QGraphicsPathItem ( path );
pathItem->setPen ( pen );
sc.addItem ( pathItem );
}
}
else if ( dr.get_pero() )
{
QPen pen ( QBrush
( QColor ( draw_vars::s_color_pen_down ), Qt::SolidPattern ),
qreal ( draw_vars::s_width_pen_down ) ,
Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin );
pen.setCosmetic ( true );
{
QPainterPath path;
path.arcMoveTo ( p_center.x - p_radius.x , p_center.y - p_radius.y , p_radius.x * 2, p_radius.y * 2, -ang_start );
path.arcTo ( p_center.x - p_radius.x , p_center.y - p_radius.y , p_radius.x * 2, p_radius.y * 2, -ang_start , -ang_number );
QGraphicsPathItem *pathItem = new QGraphicsPathItem ( path );
pathItem->setPen ( pen );
sc.addItem ( pathItem );
}
}
else
{
QPen pen ( QBrush
( QColor ( draw_vars::s_color_pen_up ), Qt::SolidPattern ),
qreal ( draw_vars::s_width_pen_up ) ,
Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin );
pen.setCosmetic ( true );
{
QPainterPath path;
path.arcMoveTo ( p_center.x - p_radius.x , p_center.y - p_radius.y , p_radius.x * 2, p_radius.y * 2, -ang_start );
path.arcTo ( p_center.x - p_radius.x , p_center.y - p_radius.y , p_radius.x * 2, p_radius.y * 2, -ang_start , -ang_number );
QGraphicsPathItem *pathItem = new QGraphicsPathItem ( path );
pathItem->setPen ( pen );
sc.addItem ( pathItem );
}
}
}
else
{
if ( dr.get_pero() )
{
QPen pen ( QBrush
( QColor ( draw_vars::s_color_pen_down ), Qt::SolidPattern ),
qreal ( draw_vars::s_width_pen_down ) ,
Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin );
pen.setCosmetic ( true );
sc.addLine ( p_start.x, p_start.y, p_end.x, p_end.y, pen );
}
else
{
QPen pen ( QBrush
( QColor ( draw_vars::s_color_pen_up ), Qt::SolidPattern ),
qreal ( draw_vars::s_width_pen_up ) ,
Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin );
pen.setCosmetic ( true );
sc.addLine ( p_start.x, p_start.y, p_end.x, p_end.y, pen );
}
}
}
}
int
kill_menu(article_header * ah)
{
int days;
register flag_type flag;
char *mode1, *mode2;
char *pattern, *dflt, *days_str, buffer[512];
group_header *gh;
days = dflt_kill_select % 100;
flag = (dflt_kill_select / 100) ? AUTO_SELECT : AUTO_KILL;
prompt("\1AUTO\1 (k)ill or (s)elect (CR => %s subject %d days) ",
flag == AUTO_KILL ? "Kill" : "Select", days);
switch (get_c()) {
case CR:
case NL:
if (ah == NULL) {
ah = get_menu_article();
if (ah == NULL)
return -1;
}
strcpy(buffer, ah->subject);
enter_kill_file(current_group, buffer,
flag | ON_SUBJECT | KILL_CASE_MATCH, days);
msg("DONE");
return 1;
case 'k':
case 'K':
case '!':
flag = AUTO_KILL;
mode1 = "KILL";
break;
case 's':
case 'S':
case '+':
flag = AUTO_SELECT;
mode1 = "SELECT";
break;
default:
return -1;
}
prompt("\1AUTO %s\1 on (s)ubject or (n)ame (s)", mode1);
dflt = NULL;
switch (get_c()) {
case 'n':
case 'N':
flag |= ON_SENDER;
if (ah)
dflt = ah->sender;
mode2 = "Name";
break;
case 's':
case 'S':
case SP:
case CR:
case NL:
flag |= ON_SUBJECT;
if (ah)
dflt = ah->subject;
mode2 = "Subject";
break;
default:
return -1;
}
prompt("\1%s %s:\1 (%=/) ", mode1, mode2);
pattern = get_s(dflt, NONE, "%=/", NULL_FCT);
if (pattern == NULL)
return -1;
if (*pattern == NUL || *pattern == '%' || *pattern == '=') {
if (dflt && *dflt)
pattern = dflt;
else {
if ((ah = get_menu_article()) == NULL)
return -1;
pattern = (flag & ON_SUBJECT) ? ah->subject : ah->sender;
}
flag |= KILL_CASE_MATCH;
} else if (*pattern == '/') {
prompt("\1%s %s\1 (regexp): ", mode1, mode2);
pattern = get_s(NONE, NONE, NONE, NULL_FCT);
if (pattern == NULL || *pattern == NUL)
return -1;
flag |= KILL_ON_REGEXP;
}
strcpy(buffer, pattern);
pattern = buffer;
prompt("\1%s\1 in (g)roup '%s' or in (a)ll groups (g)",
mode1, current_group->group_name);
switch (get_c()) {
case 'g':
case 'G':
case SP:
case CR:
case NL:
gh = current_group;
break;
case 'A':
case 'a':
gh = NULL;
break;
default:
return -1;
}
prompt("\1Lifetime of entry in days\1 (p)ermanent (30) ");
days_str = get_s(" 30 days", NONE, "pP", NULL_FCT);
if (days_str == NULL)
return -1;
if (*days_str == NUL) {
days_str = "30 days";
days = 30;
} else if (*days_str == 'p' || *days_str == 'P') {
days_str = "perm";
days = -1;
} else if (isdigit(*days_str)) {
days = atoi(days_str);
sprintf(days_str, "%d days", days);
} else {
ding();
return -1;
}
prompt("\1CONFIRM\1 %s %s %s%s: %-.35s%s ",
mode1, mode2, days_str,
(flag & KILL_CASE_MATCH) ? " exact" :
(flag & KILL_ON_REGEXP) ? " regexp" : "",
pattern, (int) strlen(pattern) > 35 ? "..." : "");
if (yes(0) <= 0)
return -1;
enter_kill_file(gh, pattern, flag, days);
return (flag & AUTO_KILL) ? 1 : 0;
}
void cstats_begin( cstats_t* csts )
{
#ifdef TIMINGS
csts->begin = get_c();
#endif
}
void FeatureCoordinates::drawPoint(cv::Mat& drawImg, const cv::Scalar& color) const{
cv::Size size(2,2);
cv::ellipse(drawImg,get_c(),size,0,0,360,color,-1,8,0);
}
void update_delta(const Expression& gradient, int index) {
if (index >= _delta.size() || index >= _old_grad.size() || index >= _g.size() || index >= _g2.size() ||
index >= _h.size() || index >= _h2.size() || index >= _tau.size() || index >= _current_iteration.size())
{
_delta.resize(index + 1);
_old_grad.resize(index + 1);
_g.resize(index + 1);
_g2.resize(index + 1);
_h.resize(index + 1);
_h2.resize(index + 1);
_tau.resize(index + 1);
_current_iteration.resize(index + 1);
}
if (!_delta[index] || !_old_grad[index] || !_g[index] || !_g2[index] || !_h[index] || !_h2[index] || !_tau[index]) {
_delta[index] = boost::make_shared<vector_t>(zeros<value_t>(gradient.count()));
_old_grad[index] = boost::make_shared<vector_t>(zeros<value_t>(gradient.count()));
_g[index] = boost::make_shared<vector_t>(zeros<value_t>(gradient.count()));
_g2[index] = boost::make_shared<vector_t>(zeros<value_t>(gradient.count()));
_h[index] = boost::make_shared<vector_t>(zeros<value_t>(gradient.count()));
_h2[index] = boost::make_shared<vector_t>(zeros<value_t>(gradient.count()));
_tau[index] = boost::make_shared<vector_t>(ones<value_t>(gradient.count()));
_current_iteration[index] = 0;
}
++_current_iteration[index];
// Detect outlier
// if (abs(reshape(gradient, _delta[index]->size()) - *_g[index]) > 2 * sqrt(*_g2[index] - *_g[index] * *_g[index]) ||
// abs(abs((reshape(gradient, _delta[index]->size()) - *_old_grad[index]) / (*_delta[index] + get_epsilon())) - *_h[index]) > 2 * sqrt(*_h2[index] - *_h[index] * *_h[index]))
// {
// *_tau[index] = *_tau[index] + 1.0;
// }
*_tau[index] = *_tau[index] + abs(reshape(gradient, _delta[index]->size()) - *_g[index]) > 2 * sqrt(*_g2[index] - *_g[index] * *_g[index]);
// Update moving averages
*_g[index] = (1.0 - 1.0 / *_tau[index]) * *_g[index] + 1.0 / *_tau[index] * reshape(gradient, _delta[index]->size());
*_g2[index] = (1.0 - 1.0 / *_tau[index]) * *_g2[index] + 1.0 / *_tau[index] * reshape(gradient, _delta[index]->size()) * reshape(gradient, _delta[index]->size());
if (_current_iteration[index] > 1) {
// Calculate h and do h updates
// diag(H) = abs((reshape(gradient, _delta[index]->size()) - *_old_grad[index]) / (*_delta[index] + get_epsilon()));
*_h[index] = (1.0 - 1.0 / *_tau[index]) * *_h[index] + 1.0 / *_tau[index] * abs((reshape(gradient, _delta[index]->size()) - *_old_grad[index]) / (*_delta[index] + get_epsilon()));
*_h2[index] = (1.0 - 1.0 / *_tau[index]) * *_h[index] + 1.0 / *_tau[index] * ((reshape(gradient, _delta[index]->size()) - *_old_grad[index]) / (*_delta[index] + get_epsilon())) * ((reshape(gradient, _delta[index]->size()) - *_old_grad[index]) / (*_delta[index] + get_epsilon()));
// Initialization phase -> multiply with C where C = D/10
if (_current_iteration[index] == 2) {
*_g2[index] = *_g2[index] * get_c();
*_h[index] = *_h[index] * get_c();
*_h2[index] = *_h2[index] * get_c();
}
*_delta[index] = -*_h[index] * *_g[index] * *_g[index] / (*_h2[index] * *_g2[index] + get_epsilon()) * reshape(gradient, _delta[index]->size());
} else {
*_delta[index] = get_epsilon() * *_g[index];
}
*_tau[index] = (1.0 - *_g[index] * *_g[index] / (*_g2[index] + get_epsilon())) * *_tau[index] + 1;
*_old_grad[index] = reshape(gradient, _delta[index]->size());
}
