/*--------------------------------------------------------------------------*/
int get_with_mesh_arg(char *fname,int pos,rhs_opts opts[], BOOL * withMesh)
{
int m,n,l,first_opt=FirstOpt(),kopt;
if (pos < first_opt)
{
if (VarType(pos))
{
GetRhsVar(pos,MATRIX_OF_BOOLEAN_DATATYPE, &m, &n, &l);
CheckLength(pos,m*n,1);
*withMesh = *(istk(l));
}
else
{
/** global value can be modified **/
setDefWithMesh( FALSE );
*withMesh = getDefWithMesh() ;
}
}
else if ((kopt=FindOpt("mesh",opts)))
{
GetRhsVar(kopt,MATRIX_OF_BOOLEAN_DATATYPE, &m, &n, &l);
CheckLength(kopt,m*n,1);
*withMesh = *(istk(l));
}
else
{
/** global value can be modified **/
setDefWithMesh( FALSE );
*withMesh = getDefWithMesh() ;
}
return 1;
}
/*--------------------------------------------------------------------------*/
int get_colout_arg(char *fname,int pos,rhs_opts opts[], int ** colout )
{
int m,n,l,first_opt=FirstOpt(),kopt;
if (pos < first_opt)
{
if (VarType(pos))
{
GetRhsVar(pos,MATRIX_OF_INTEGER_DATATYPE, &m, &n, &l);
CheckLength(pos,m*n,2);
*colout = istk(l);
}
else
{
/** global value can be modified **/
int newDefCO[2] = { -1, -1 } ;
setDefColOut( newDefCO ) ;
*colout = getDefColOut() ;
}
}
else if ((kopt=FindOpt("colout",opts)))
{
GetRhsVar(kopt,MATRIX_OF_INTEGER_DATATYPE, &m, &n, &l);
CheckLength(kopt,m*n,2);
*colout=istk(l);
}
else
{
/** global value can be modified **/
int newDefCO[2] = { -1, -1 } ;
setDefColOut( newDefCO ) ;
*colout = getDefColOut() ;
}
return 1;
}
/*--------------------------------------------------------------------------*/
int get_colminmax_arg(char *fname,int pos,rhs_opts opts[], int ** colminmax )
{
int m,n,l,first_opt=FirstOpt(),kopt;
if (pos < first_opt)
{
if (VarType(pos))
{
GetRhsVar(pos,MATRIX_OF_INTEGER_DATATYPE, &m, &n, &l);
CheckLength(pos,m*n,2);
*colminmax=istk(l);
}
else
{
/** global value can be modified **/
int zeros[2] = { 0, 0 } ;
setDefColMinMax( zeros ) ;
*colminmax = getDefColMinMax() ;
}
}
else if ((kopt=FindOpt("colminmax",opts)))
{
GetRhsVar(kopt,MATRIX_OF_INTEGER_DATATYPE, &m, &n, &l);
CheckLength(kopt,m*n,2);
*colminmax=istk(l);
}
else
{
/** global value can be modified **/
int zeros[2] = { 0, 0 } ;
setDefColMinMax( zeros ) ;
*colminmax = getDefColMinMax() ;
}
return 1;
}
/*--------------------------------------------------------------------------*/
int get_nax_arg(int pos,rhs_opts opts[], int ** nax, BOOL * flagNax )
{
int i,m,n,l,first_opt=FirstOpt(),kopt;
if (pos < first_opt)
{
if (VarType(pos))
{
GetRhsVar(pos,MATRIX_OF_INTEGER_DATATYPE, &m, &n, &l);
CheckLength(pos,m*n,4);
for (i = 0 ; i < 4; ++i)
{
// When i = 1 or 3 we talk about the number of ticks, this value can be -1 to say 'AutoTicks'
*istk(l+i) = Max((int) *istk(l+i),-(i%2));
}
*nax=istk(l);
*flagNax = TRUE;
}
else
{
*nax = getDefNax() ;
*flagNax = FALSE;
}
}
else if ((kopt=FindOpt("nax",opts)))
{
GetRhsVar(kopt,MATRIX_OF_INTEGER_DATATYPE, &m, &n, &l);
CheckLength(kopt,m*n,4);
for (i = 0 ; i < 4; ++i)
{
// When i = 1 or 3 we talk about the number of ticks, this value can be -1 to say 'AutoTicks'
*istk(l+i) = Max((int) *istk(l+i),-(i%2));
}
*nax=istk(l);
*flagNax = TRUE;
}
else
{
*nax = getDefNax() ;
*flagNax = FALSE;
}
return 1;
}
//检查124
BOOL CStringChecker::CheckName( LPCTSTR cStr )
{
BOOL b;
b = CheckWindowsRuler(cStr);
if(!b) return b;
b = CheckSpacePoint(cStr);
if(!b) return b;
b = CheckLength(cStr, 20);
return b;
}
//检查1245
BOOL CStringChecker::CheckDirName( LPCTSTR cStr )
{
// BOOL b;
// b = CheckEmpty(cStr);
// if(!b) return b;
// b = CheckWindowsRuler(cStr);
// if(!b) return b;
// b = CheckSpacePoint(cStr);
// if(!b) return b;
// b = CheckLength(cStr, 20);
// return b;
//char str[] = "^[a-zA-Z_\\xB0-\\xF7\\xA1-\\xFE][a-zA-Z0-9_\\xB0-\\xF7\\xA1-\\xFE]*$";
//BOOL b = RegexMatch(cStr, str);
BOOL b = TRUE;
LPCTSTR p = cStr;
unsigned char c = *p;
//if(c >= '0' && c <= '9') b =FALSE;
//else
while(c = *p++)
{
if((c < '0' || c > '9') && (c < 'a' || c > 'z') && (c < 'A' || c > 'Z') && c != '_' )
{
if(
(c >= 0xB0 && c<= 0xF7 && UCHAR(*p) >= 0xA1 && UCHAR(*p) <= 0xFE)
|| (c == 0xA6 && UCHAR(*p) >= 0xA1 && UCHAR(*p) <= 0xFE)
)
{//属于汉字范围(16-87区)或希腊字母(6区)
p++;
continue;
}
if (c=='-') // 允许文件夹名称有中画线杠'-'
continue;
b = FALSE;
break;
}
}
if(CString(cStr).FindOneOf(CStringCheckerConfig::CheckFilter) != -1)
{//字符查找
b = FALSE;
}
if(!b)
{
SetLastErr(CStringCheckerConfig::CheckErrorDir);
return b;
}
b = CheckEmpty(cStr);
if(!b) return b;
b = CheckLength(cStr, 20);
return b;
}
bool cCardClientRadegast::ProcessECM(const cEcmInfo *ecm, const unsigned char *source, unsigned char *cw)
{
cMutexLock lock(this);
if((!so.Connected() && !Login()) || !CanHandle(ecm->caId)) return false;
so.Flush();
int len=SCT_LEN(source);
int keynr=-1;
switch(ecm->caId>>8) {
case 0x01: // Seca
keynr=cParseSeca::KeyNr(source)&0x0F; break;
case 0x05: // Viaccess
keynr=cParseViaccess::KeyNr(source); break;
case 0x18: // Nagra2
if(ecm->caId>=0x1801) keynr=(source[7]&0x10) | 0x86;
break;
}
unsigned char buff[512], tmp[10];
StartMsg(buff,1); // CMD_ECM_KEY_ASK
AddNano(buff,2,1,ecm->caId>>8); // ECM_NANO_CAID_INDEX (old)
AddNano(buff,10,2,ecm->caId); // ECM_NANO_CAID
sprintf((char *)tmp,"%08X",ecm->provId);
AddNano(buff,6,8,tmp); // ECM_NANO_PROVIDER
if(keynr>=0) {
sprintf((char *)tmp,"%04X",keynr);
AddNano(buff,7,4,tmp); // ECM_NANO_KEYNO
}
if(!CheckLength(buff,len)) return false;
AddNano(buff,3,len,source); // ECM_NANO_PACKET
if(!Send(buff) || (len=Recv(buff,sizeof(buff)))<0) return false;
if(buff[0]==2) {
for(int l=GetNanoStart(buff); l<len; l+=buff[l+1]+2) {
switch(buff[l]) {
case 0x05:
if(buff[l+1]==16) {
// check for zero cw, as someone may not send both cw's every time
if(!CheckNull(buff+l+ 2,8)) memcpy(cw+0,buff+l+ 2,8);
if(!CheckNull(buff+l+10,8)) memcpy(cw+8,buff+l+10,8);
return true;
}
else PRINTF(L_CC_RDGD,"wrong cw length %d from server",buff[l+1]);
break;
case 0x04:
PRINTF(L_CC_ECM,"%s: key not available from server",name);
break;
default:
PRINTF(L_CC_RDGD,"unknown nano %02x in ECM response",buff[l]);
break;
}
}
}
else PRINTF(L_CC_RDGD,"bad ECM response from server %02x != 02",buff[0]);
return false;
}
/*--------------------------------------------------------------------------*/
int get_optional_int_arg( char * fname,
int pos ,
char * name ,
int ** value,
int sz ,
rhs_opts opts[] )
{
int m,n,l,first_opt=FirstOpt(),kopt;
if (pos < first_opt)
{
if (VarType(pos)) {
GetRhsVar(pos,MATRIX_OF_INTEGER_DATATYPE, &m, &n, &l);
CheckLength(pos,m*n,sz)
*value = istk(l);
}
}
else if ((kopt=FindOpt(name,opts))) {
GetRhsVar(kopt,MATRIX_OF_INTEGER_DATATYPE, &m, &n, &l);
CheckLength(kopt,m*n,sz)
*value = istk(l);
}
return 1;
}
void CNPC_Hydra::RunAI( void )
{
CheckLength( );
AdjustLength( );
BaseClass::RunAI();
CalcGoalForces( );
MoveBody( );
int i;
for (i = 1; i < CHAIN_LINKS && i < m_body.Count(); i++)
{
m_vecChain.Set( i, m_body[i].vecPos );
#if 0
if (m_body[i].bStuck)
{
NDebugOverlay::Box(m_body[i].vecPos, Vector( -2, -2, -2 ), Vector( 2, 2, 2 ), 255, 0, 0, 20, .1);
}
else
{
NDebugOverlay::Box(m_body[i].vecPos, Vector( -2, -2, -2 ), Vector( 2, 2, 2 ), 0, 255, 0, 20, .1);
}
NDebugOverlay::Line( m_body[i].vecPos, m_body[i].vecPos + m_body[i].vecDelta, 0, 255, 0, true, .1);
NDebugOverlay::Line( m_body[i-1].vecPos, m_body[i].vecPos, 255, 255, 255, true, .1);
#endif
#if 0
char text[128];
Q_snprintf( text, sizeof( text ), "%d", i );
NDebugOverlay::Text( m_body[i].vecPos, text, false, 0.1 );
#endif
#if 0
char text[128];
Q_snprintf( text, sizeof( text ), "%4.0f", (m_body[i].vecPos - m_body[i-1].vecPos).Length() * 100 / m_idealSegmentLength - 100);
NDebugOverlay::Text( 0.5*(m_body[i-1].vecPos + m_body[i].vecPos), text, false, 0.1 );
#endif
}
//NDebugOverlay::Box(m_body[i].vecPos, Vector( -2, -2, -2 ), Vector( 2, 2, 2 ), 0, 255, 0, 20, .1);
//NDebugOverlay::Box( m_vecHeadGoal, Vector( -2, -2, -2 ), Vector( 2, 2, 2 ), 255, 255, 0, 20, .1);
for (; i < CHAIN_LINKS; i++)
{
m_vecChain.Set( i, m_vecChain[i-1] );
}
}
void Debug_PrintFile(const char *format, ...)
{
va_list ap;
if( Debug_Inited() == FALSE )
{
return;
}
va_start(ap, format);
CheckLength();
CurrentLength += vfprintf(Debug_File, format, ap);
fflush(Debug_File);
va_end(ap);
}
bool NIFeb2015BinFile::ReadNextEvent(BinEv_t& NI_event) {
FebBinEv_t* Feb_event = dynamic_cast<FebBinEv_t*>(&NI_event);
if (!Feb_event) {
cout << "NIFeb2015BinFile::ReadNextEvent() requires FebBinEv_t types" << endl;
return false;
}
if (!IsOpen())
return false;
if (!readheader)
ReadHeader();
if (!CheckLength())
return false;
fFileStream.read(reinterpret_cast<char *>(&(Feb_event->timestamp)),8);
int numch;
fFileStream.read(reinterpret_cast<char *>(&numch),4);
Feb_event->ch.resize(numch);
for (int ch=0;ch<numch;ch++)
fFileStream.read(reinterpret_cast<char *>(&(Feb_event->ch[ch].Edaq)),2);
int wavelen;
fFileStream.read(reinterpret_cast<char *>(&wavelen),4);
wavelen = wavelen/8.;
if (wavelen > MAXWAVE) {
cout << endl;
cout << GetPosition() << endl;
for (int i=0;i<Feb_event->ch.size();i++)
cout << Feb_event->ch[i].Edaq << " ";
cout << endl;
cout << Feb_event->timestamp << endl;
cout << "Error in wavelength " << wavelen << endl;
return false;
}
for (int ch=0;ch<numch;ch++) {
Feb_event->ch[ch].wave.resize(wavelen);
fFileStream.read(reinterpret_cast<char *>(&(Feb_event->ch[ch].wave[0])),wavelen*2);
}
return true;
}
bool cCardClientRadegast::ProcessEMM(int caSys, const unsigned char *data)
{
if(emmProcessing && emmAllowed) {
cMutexLock lock(this);
int upd;
cProvider *p;
cAssembleData ad(data);
if(MatchAndAssemble(&ad,&upd,&p)) {
while((data=ad.Assembled())) {
int len=SCT_LEN(data);
int id=msEMM.Get(data,len,0);
if(id>0 || emmAllowed>1) {
unsigned char buff[512];
StartMsg(buff,0x41); //
AddNano(buff,0x42,2,caSys); // EMM_CAID
if(p) {
unsigned char tmp[10];
sprintf((char *)tmp,"%08X",(int)p->ProvId());
AddNano(buff,0x46,8,tmp); // EMM_PROVID
}
/*
if(upd==2 || upd==3) {
AddNano(buff,0x44,2,(unsigned char *)"aa"); // EMM_ADDR_VAL
}
*/
AddNano(buff,0x45,1,upd==3 ? 0x11 : (upd==2 ? 0x12 : 0x13)); // EMM_ADDR_TYPE
if(CheckLength(buff,len)) {
AddNano(buff,0x43,len,data); // EMM_CA_DATA
Send(buff);
}
msEMM.Cache(id,true,0);
}
}
return true;
}
}
return false;
}
/*--------------------------------------------------------------------------*/
int sci_gsort(char *fname, unsigned long fname_len)
{
char iord[2];
char typex[10];
SciIntMat Im;
int Type = 0;
char **S = NULL;
int m1 = 0, n1 = 0, l1 = 0;
int m2 = 0, n2 = 0, l2 = 0;
int m3 = 0, n3 = 0, l3 = 0;
int ind_m1 = 0, ind_n1 = 0;
int *indices = NULL;
int iflag = 0;
int i;
iord[0] = DECREASE_COMMAND;
iord[1] = '\0';
typex[0] = GLOBAL_SORT;
typex[1] = '\0';
Rhs = Max(0, Rhs);
CheckRhs(1, 3);
CheckLhs(1, 2);
if (Rhs >= 1)
{
Type = VarType(1);
switch (Type)
{
case sci_strings:
GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &m1, &n1, &S);
break;
case sci_matrix:
{
#define COMPLEX 1
int *header = NULL;
int Cmplx = 0;
header = (int *)GetData(1);
Cmplx = header[3];
if (Cmplx == COMPLEX)
{
return gsort_complex(fname, typex, iord);
}
else
{
GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
if ((m1 * n1) == 0) /* [] returns [] */
{
int m = 0, n = 0, l = 0;
CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &m, &n, &l);
LhsVar(1) = Rhs + 1;
if (Lhs == 2)
{
CreateVar(Rhs + 2, MATRIX_OF_DOUBLE_DATATYPE, &m, &n, &l);
LhsVar(2) = Rhs + 2;
}
PutLhsVar();
return 0;
}
}
}
break;
case sci_ints:
GetRhsVar(1, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &m1, &n1, &Im);
break;
case sci_sparse:
default:
OverLoad(1);
return 0;
break;
}
}
if (Rhs == 3)
{
GetRhsVar(3, STRING_DATATYPE, &m3, &n3, &l3);
CheckLength(3, m3, 1);
if ((*cstk(l3) != INCREASE_COMMAND) && (*cstk(l3) != DECREASE_COMMAND))
{
Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), fname, 3, "i", "d");
return 0;
}
iord[0] = *cstk(l3);
}
if (Rhs >= 2)
{
char c;
GetRhsVar(2, STRING_DATATYPE, &m2, &n2, &l2);
if (m2 == 0)
{
Scierror(999, _("%s: Wrong size for input argument #%d: Non-empty string expected.\n"), fname, 2);
return 0;
}
c = *cstk(l2);
if ((c != ROW_SORT) && (c != COLUMN_SORT) && (c != GLOBAL_SORT) && (c != LIST_SORT))
{
Scierror(999, _("%s: Wrong value for input argument #%d: '%s', '%s', '%s', '%s' or '%s' expected.\n"), fname, 2, "r", "c", "g", "lr",
"lc");
return 0;
}
strcpy(typex, cstk(l2));
}
if (typex[0] == LIST_SORT)
{
if (typex[1] == ROW_SORT)
{
ind_m1 = m1;
ind_n1 = 1;
if (ind_m1 != 0)
indices = (int *)MALLOC(sizeof(int) * (ind_m1)); /* Only return in row */
}
else if (typex[1] == COLUMN_SORT)
{
ind_m1 = 1;
ind_n1 = n1;
if (ind_n1 != 0)
indices = (int *)MALLOC(sizeof(int) * (ind_n1)); /*Only return in col */
}
else
{
Scierror(999, _("%s: Wrong value for input argument #%d.\n"), fname, 2);
return 0;
}
}
else
{
ind_m1 = m1;
ind_n1 = n1;
if (ind_m1 * ind_n1 != 0)
indices = (int *)MALLOC(sizeof(int) * (ind_m1 * ind_n1)); /* return a matrix */
}
if (Lhs == 2)
iflag = 1;
else
iflag = 0;
switch (Type)
{
case sci_matrix:
{
if (m1 * n1 != 0)
{
int lr;
double *matrix = stk(l1);
double *tmp_matrix = NULL;
/* next CreateVar and corresponding copy not needed if arg1 is not passed by reference */
if (!CreateVarNoCheck(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &lr))
{
if (indices)
{
FREE(indices);
indices = NULL;
}
return 0;
}
tmp_matrix = stk(lr);
for (i = 0; i < m1 * n1; i++)
tmp_matrix[i] = matrix[i];
C2F(gsortd) (tmp_matrix, indices, &iflag, &m1, &n1, typex, iord);
LhsVar(1) = Rhs + 1;
if (Lhs == 2)
{
if (!CreateVarFromPtrNoCheck(Rhs + 2, MATRIX_OF_INTEGER_DATATYPE, &ind_m1, &ind_n1, &indices))
{
if (indices)
{
FREE(indices);
indices = NULL;
}
return 0;
}
LhsVar(2) = Rhs + 2;
}
if (indices)
{
FREE(indices);
indices = NULL;
}
PutLhsVar();
}
}
break;
case sci_ints:
{
int lr;
lr = Im.it;
/* next CreateVar and corresponding copy not needed if arg1 is not passed by reference */
if (!CreateVarNoCheck(Rhs + 1, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &m1, &n1, &lr))
{
if (indices)
{
FREE(indices);
indices = NULL;
}
return 0;
}
switch (Im.it) /* Type defined in stack-c.h */
{
case I_CHAR:
{
char *matrix = Im.D;
char *tmp_matrix = (char *)istk(lr);
for (i = 0; i < m1 * n1; i++)
tmp_matrix[i] = matrix[i];
C2F(gsortchar) (tmp_matrix, indices, &iflag, &m1, &n1, typex, iord);
}
break;
case I_INT32:
{
int *matrix = Im.D;
int *tmp_matrix = istk(lr);
for (i = 0; i < m1 * n1; i++)
tmp_matrix[i] = matrix[i];
C2F(gsortint) (tmp_matrix, indices, &iflag, &m1, &n1, typex, iord);
}
break;
case I_UCHAR:
{
unsigned char *matrix = Im.D;
unsigned char *tmp_matrix = (unsigned char *)istk(lr);
for (i = 0; i < m1 * n1; i++)
tmp_matrix[i] = matrix[i];
C2F(gsortuchar) (tmp_matrix, indices, &iflag, &m1, &n1, typex, iord);
}
break;
case I_INT16:
{
short *matrix = Im.D;
short *tmp_matrix = (short *)istk(lr);
for (i = 0; i < m1 * n1; i++)
tmp_matrix[i] = matrix[i];
C2F(gsortshort) (tmp_matrix, indices, &iflag, &m1, &n1, typex, iord);
}
break;
case I_UINT16:
{
unsigned short *matrix = Im.D;
unsigned short *tmp_matrix = (short *)istk(lr);
for (i = 0; i < m1 * n1; i++)
tmp_matrix[i] = matrix[i];
C2F(gsortushort) (tmp_matrix, indices, &iflag, &m1, &n1, typex, iord);
}
break;
case I_UINT32:
{
unsigned int *matrix = Im.D;
unsigned int *tmp_matrix = (unsigned int *)istk(lr);
for (i = 0; i < m1 * n1; i++)
tmp_matrix[i] = matrix[i];
C2F(gsortuint) (tmp_matrix, indices, &iflag, &m1, &n1, typex, iord);
}
break;
default:
if (indices)
{
FREE(indices);
indices = NULL;
}
Scierror(999, _("%s: Wrong type for input argument #%d: Unknown type.\n"), fname, 1);
return 0;
}
LhsVar(1) = Rhs + 1;
if (Lhs == 2)
{
if (!CreateVarFromPtrNoCheck(Rhs + 2, MATRIX_OF_INTEGER_DATATYPE, &ind_m1, &ind_n1, &indices))
{
if (indices)
{
FREE(indices);
indices = NULL;
}
return 0;
}
LhsVar(2) = Rhs + 2;
}
if (indices)
{
FREE(indices);
indices = NULL;
}
PutLhsVar();
}
break;
case sci_strings:
{
C2F(gsorts) (S, indices, &iflag, &m1, &n1, typex, iord);
if (!CreateVarFromPtrNoCheck(Rhs + 1, MATRIX_OF_STRING_DATATYPE, &m1, &n1, S))
{
if (indices)
{
FREE(indices);
indices = NULL;
}
return 0;
}
LhsVar(1) = Rhs + 1;
if (Lhs == 2)
{
if (!CreateVarFromPtrNoCheck(Rhs + 2, MATRIX_OF_INTEGER_DATATYPE, &ind_m1, &ind_n1, &indices))
{
if (indices)
{
FREE(indices);
indices = NULL;
}
return 0;
}
LhsVar(2) = Rhs + 2;
}
if (indices)
{
FREE(indices);
indices = NULL;
}
freeArrayOfString(S, m1 * n1);
PutLhsVar();
}
break;
default:
if (indices)
{
FREE(indices);
indices = NULL;
}
Scierror(999, _("%s: Wrong type for input argument #%d.\n"), fname, 1);
return 0;
break;
}
return 0;
}
/*--------------------------------------------------------------------------*/
int sci_qp_solve(char *fname, unsigned long fname_len)
{
static int un = 1, deux = 2;
// n : first dimension of Q
// nbis : second dimension of Q (nbis is expected to be equal to n)
static int Q = 0, n = 0, nbis = 0;
static int p = 0, unbis = 0;
static int C = 0, m = 0;
static int b = 0, mbis = 0;
static int me = 0, pipo = 0;
static int x = 0, iter = 0, iact = 0, nact = 0, crval = 0, ierr = 0;
int r = 0;
static int lw = 0, k = 0;
static SciSparse Sp;
static int issparse = 0;
double *work = NULL;
/* Check rhs and lhs */
CheckRhs(5, 5) ;
CheckLhs(1, 4) ;
/*Warning this interface does not support arguments passed by reference */
/* RhsVar: qp_solve(Q,p,C,b,me) */
/* 1,2,3,4,5 */
/* Variable 1 (Q) */
GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &n, &nbis, &Q);
CheckSquare(1, n, nbis);
/* Variable 2 (p) */
GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &nbis, &unbis, &p);
CheckLength(2, nbis * unbis, n);
/* Variable 3 (C) */
issparse = (GetType(3) == 5);
if (!issparse)
{
GetRhsVar(3, MATRIX_OF_DOUBLE_DATATYPE, &nbis, &m, &C);
}
else
{
GetRhsVar(3, SPARSE_MATRIX_DATATYPE, &nbis, &m, &Sp);
}
if ( nbis != n ) // car C est passee en transposee dans la macro qpsolve
{
Scierror(999, _("%s: Wrong size for input argument #%d: %d column(s) expected for matrix %s.\n"), fname, 3, n, "C");
return 0;
}
/* Variable 4 (b) */
GetRhsVar(4, MATRIX_OF_DOUBLE_DATATYPE, &mbis, &unbis, &b);
CheckLength(4, mbis * unbis, m);
/* Variable 5 (me) */
GetRhsVar(5, MATRIX_OF_INTEGER_DATATYPE, &pipo, &unbis, &me);
CheckScalar(5, pipo, unbis);
if ((*istk(me) < 0) || (*istk(me) > n))
{
Scierror(999, _("%s: Wrong value for input argument #%d: %s must be an integer in the range 0 to %d.\n"), fname, 5, "me", n);
return 0;
}
/* Lhs variables: x, iact, iter, crval */
CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &n, &un, &x);
CreateVar(Rhs + 2, MATRIX_OF_INTEGER_DATATYPE, &m, &un, &iact);
CreateVar(Rhs + 3, MATRIX_OF_INTEGER_DATATYPE, &deux, &un, &iter);
CreateVar(Rhs + 4, MATRIX_OF_DOUBLE_DATATYPE, &un, &un, &crval);
r = Min(n, m);
lw = 2 * n + r * (r + 5) / 2 + 2 * m + 1;
if ((work = (double *)MALLOC(lw * sizeof(double))) == NULL)
{
Scierror(999, _("%s: Cannot allocate more memory.\n"), fname);
}
/* change the sign of C and b.*/
ierr = 0;
if (!issparse)
{
/* linear constraints matrix is stored full */
C2F(qpgen2)(stk(Q), stk(p), &n, &n, stk(x), stk(crval), stk(C),
stk(b), &n, &m, istk(me), istk(iact), &nact, istk(iter), work,
&ierr);
}
else
{
/* linear constraints matrix is a sparse matrix */
/* Change the linear constraints matrix representation:
qpgen1sci requires column-compressed sparse matrix internal
representation while Scilab sparse matrices are row-compressed */
double *R = NULL, *I = NULL;
int *ind = NULL;
if ((R = (double *)MALLOC(Sp.nel * sizeof(double))) == NULL)
{
FREE(work);
work = NULL;
Scierror(999, _("%s: Cannot allocate more memory.\n"), fname);
}
if ((ind = (int *)MALLOC((m + Sp.nel) * sizeof(int))) == NULL)
{
FREE(work);
work = NULL;
FREE(R);
R = NULL;
Scierror(999, _("%s: Cannot allocate more memory.\n"), fname);
}
// Transpose the sparse matrix A
C2F(spt)(&n, &m, &(Sp.nel) , &(Sp.it), (int *)work,
Sp.R, Sp.I, Sp.mnel, Sp.icol, R, I, ind, ind + m);
C2F(qpgen1sci)(stk(Q), stk(p), &n, &n, stk(x), stk(crval),
ind, ind + m, R,
stk(b), &m, istk(me), istk(iact), &nact, istk(iter),
work, &ierr);
FREE(work);
work = NULL;
FREE(R);
R = NULL;
FREE(ind);
ind = NULL;
}
for (k = nact; k < m; k++) istk(iact)[k] = 0;
/* LhsVar: [x, iact, iter, f] = qp_solve(...) */
if (ierr == 0)
{
for (k = 0; k < Lhs; k++) LhsVar(1 + k) = Rhs + 1 + k;
PutLhsVar();
}
else if (ierr == 1)
{
Scierror(999, _("%s: The minimization problem has no solution.\n"), fname);
}
else if (ierr == 2)
{
Scierror(999, _("%s: Q is not symmetric positive definite.\n"), fname);
}
return 0;
}
//检查12345
BOOL CStringChecker::CheckNodeName( LPCTSTR cStr )
{
// BOOL b;
// b = CheckEmpty(cStr);
// if(!b) return b;
// b = CheckWindowsRuler(cStr);
// if(!b) return b;
// b = CheckSpacePoint(cStr);
// if(!b) return b;
// b = CheckFirstNumber(cStr);
// if(!b) return b;
// b = CheckLength(cStr, 50);
// return b;
//char str[] = "^[a-zA-Z_\\xB0-\\xF7\\xA1-\\xFE][a-zA-Z0-9_\\xB0-\\xF7\\xA1-\\xFE]*$";
//BOOL b = RegexMatch(cStr, str);
BOOL b = TRUE;
LPCTSTR p = cStr;
unsigned char c = *p;
//if(c >= '0' && c <= '9') b =FALSE;
//if(CheckIntNumber(cStr))b = FALSE;
{
char str[] = "^\\d+$";
CString strTemp(cStr);
//strTemp.Replace('-', '1');
b = !RegexMatch(strTemp, str);
}
if(!b )
{
}
else while(c = *p++)
{
if((c < '0' || c > '9') && (c < 'a' || c > 'z') && (c < 'A' || c > 'Z') && c != '_' && c != '-') //允许参数名含有减号
//if((c < '0' || c > '9') && (c < 'a' || c > 'z') && (c < 'A' || c > 'Z') && c != '_' )
{
if(
(c >= 0xB0 && c<= 0xF7 && UCHAR(*p) >= 0xA1 && UCHAR(*p) <= 0xFE)
|| (c == 0xA6 && UCHAR(*p) >= 0xA1 && UCHAR(*p) <= 0xFE)
)
{//属于汉字范围(16-87区)或希腊字母(6区)
p++;
continue;
}
b = FALSE;
break;
}
}
if(CString(cStr).FindOneOf(CStringCheckerConfig::CheckFilter) != -1)
{//字符查找
b = FALSE;
}
if(!b)
{
SetLastErr(CStringCheckerConfig::CheckErrorNode);
return b;
}
b = CheckEmpty(cStr);
if(!b) return b;
b = CheckLength(cStr, 50);
return b;
}
BOOL CStringChecker::CheckParamName( LPCTSTR cStr )
{
{
CString sCheckString(cStr);
if (sCheckString.Find("双击添加参数") != -1)
{
SetLastErr(CStringCheckerConfig::CheckErrorParamCustom);
return FALSE;
}
}
BOOL b = TRUE;
LPCTSTR p = cStr;
int nlenth =0;
unsigned char c = *p;
nlenth = strlen(cStr);
if (cStr[0]==0x20||cStr[nlenth-1]==0x20)
{
SetLastErr(CStringCheckerConfig::CheckErrorParam);
return FALSE;
}
{
char str[] = "^\\d+$";
CString strTemp(cStr);
//空格,点和斜杠不能和纯数字一起用
strTemp.Replace(' ', '1');
strTemp.Replace('.', '1');
strTemp.Replace('\\', '1');
//strTemp.Replace('-', '1');
b = !RegexMatch(strTemp, str);
}
if(!b)
{
}
else while(c = *p++)
{
if((c < '0' || c > '9') && (c < 'a' || c > 'z') && (c < 'A' || c > 'Z') && \
(c != '_')&& (c!='\\') && (c!='.') &&(c!=' ') &&(c!='-') )//允许参数名含有减号、.和\。
{
if(
(c >= 0xB0 && c<= 0xF7 && UCHAR(*p) >= 0xA1 && UCHAR(*p) <= 0xFE)
|| (c == 0xA6 && UCHAR(*p) >= 0xA1 && UCHAR(*p) <= 0xFE))
{//属于汉字范围(16-87区)或希腊字母(6区)
p++;
continue;
}
b = FALSE;
break;
}
}
if(!b)
{
SetLastErr(CStringCheckerConfig::CheckErrorParam);
return b;
}
b = CheckEmpty(cStr);
if(!b) return b;
b = CheckLength(cStr, 50);
return b;
}
/*--------------------------------------------------------------------------*/
int sci_xrect( char *fname, unsigned long fname_len )
{
long hdl = 0;
int m1 = 0,n1 = 0,l1 = 0,m2 = 0,n2 = 0,l2 = 0,m3 = 0,n3 = 0,l3 = 0,m4 = 0,n4 = 0,l4 = 0;
char* psubwinUID = NULL;
int foreground = 0;
int *piForeground = &foreground;
CheckRhs(1,4);
psubwinUID = (char*)getOrCreateDefaultSubwin();
switch( Rhs )
{
case 1 :
GetRhsVar(1,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l1);
CheckLength(1,m1*n1,4);
getGraphicObjectProperty(psubwinUID, __GO_LINE_COLOR__, jni_int, (void**)&piForeground);
if (strcmp(fname,"xrect")==0)
{
Objrect (stk(l1),stk(l1+1),stk(l1+2),stk(l1+3),
&foreground,NULL,FALSE,TRUE,&hdl);
}
else
{ /* xfrect case */
Objrect (stk(l1),stk(l1+1),stk(l1+2),stk(l1+3),
NULL,&foreground,TRUE,FALSE,&hdl);
}
if ( hdl < 0 )
{
break;
}
break;
case 4 :
getGraphicObjectProperty(psubwinUID, __GO_LINE_COLOR__, jni_int, (void**)&piForeground);
GetRhsVar(1,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l1); CheckScalar(1,m1,n1);
GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE,&m2,&n2,&l2); CheckScalar(2,m2,n2);
GetRhsVar(3,MATRIX_OF_DOUBLE_DATATYPE,&m3,&n3,&l3); CheckScalar(3,m3,n3);
GetRhsVar(4,MATRIX_OF_DOUBLE_DATATYPE,&m4,&n4,&l4); CheckScalar(4,m4,n4);
if (strcmp(fname,"xrect")==0)
{
Objrect (stk(l1),stk(l2),stk(l3),stk(l4),
&foreground,NULL,FALSE,TRUE,&hdl);
}
else
{
Objrect (stk(l1),stk(l2),stk(l3),stk(l4),
NULL,&foreground,TRUE,FALSE,&hdl);
}
if ( hdl < 0 )
{
break;
}
break;
default :
Scierror(999,_("%s: Wrong number of input argument(s): %d or %d expected.\n"),fname, 1,4);
break ;
}
if ( hdl > 0 )
{
setGraphicObjectRelationship(psubwinUID, getObjectFromHandle(hdl));
LhsVar(1)=0;
PutLhsVar();
}
return 0;
}
