DataSource * RandTime :: FromXML( const ALib::XMLElement * e ) {
ForbidChildren( e );
AllowAttrs( e, AttrList( BEGIN_ATTRIB, END_ATTRIB, MODE_ATTR,
ORDER_ATTRIB, 0 ));
bool havemode = false;
TimeRep begin, end, mode;
try {
if ( e->HasAttr( BEGIN_ATTRIB ) || e->HasAttr( END_ATTRIB ) ) {
begin = TimeRep( e->AttrValue( BEGIN_ATTRIB ) );
end = TimeRep( e->AttrValue( END_ATTRIB ) );
if ( begin.AsInt() >= end.AsInt() ) {
throw Exception( "begin must be before end" );
}
}
if ( e->HasAttr( MODE_ATTR ) ) {
havemode = true;
mode = TimeRep( e->AttrValue( MODE_ATTR ) );
}
}
catch( const Exception & ex ) {
XMLERR( e, ex.what() );
}
// std::cout << begin.Str() <<" " << end.Str() << std::endl;
if ( havemode ) {
return new RandTime( GetOrder( e ), begin, end, mode );
}
else {
return new RandTime( GetOrder( e ), begin, end );
}
}
bool CppECGroup::IsProbablyValid() const
{
return IsElement(GetGenerator()) &&
IsIdentity(Exponentiate(GetGenerator(), GetOrder())) &&
CryptoPP::IsPrime(_curve.FieldSize()) &&
GetOrder().IsPrime();
}
void VQModel::Train(const std::vector< DynamicVector<Real> >& samples, unsigned int iterations)
{
LBG lbg(GetOrder());
mClusterWeights.resize(GetOrder());
ResetWeights();
std::vector<unsigned int> indices;
lbg.Cluster(samples, indices, mClusterCentroids, mClusterSizes);
}
DataSource * TimeSeq :: FromXML( const ALib::XMLElement * e ) {
ForbidChildren( e );
AllowAttrs( e, AttrList( BEGIN_ATTRIB, END_ATTRIB,
INC_ATTRIB, ORDER_ATTRIB, 0 ));
RequireAttrs( e, AttrList( BEGIN_ATTRIB, END_ATTRIB, 0 ) );
TimeRep begin, end;
try {
begin = TimeRep( e->AttrValue( BEGIN_ATTRIB ) );
end = TimeRep( e->AttrValue( END_ATTRIB ) );
if ( begin.AsInt() >= end.AsInt() ) {
throw Exception( "begin must be before end" );
}
}
catch ( const Exception & ex ) {
XMLERR( e, ex.what() );
}
int inc = GetInt( e, INC_ATTRIB, "1" );
if ( inc <= 0 || inc >= 24 * 60 * 60 ) {
XMLERR( e, "Invalid increment: " << inc );
}
return new TimeSeq( GetOrder( e ), begin, end, inc );
}
DataSource * DSSelect :: FromXML( const ALib::XMLElement * e ) {
AllowAttrs( e, AttrList( ORDER_ATTRIB, 0 ) );
RequireChildren( e );
CheckKids( e );
std::auto_ptr <DSSelect> sl( new DSSelect( GetOrder( e ) ) );
sl->AddChildSources( e );
return sl.release();
}
float CTElection::GetRetRate( u_long idPlayer )
{ // 입찰금 반환율
int nOrder = GetOrder( idPlayer );
nOrder = min( nOrder, IElection::nMaxCandidates );
if( nOrder < 0 )
return 0.0F;
return property.m_vReturnDepositRates[nOrder];
}
void PageConfigData::Fitcurve(double dx[],double dy[],int nNum,int nCol)
{
double dParam[5] = {0,0,0,0,0};
int ma = GetOrder();
Polyfit(dx,dy,nNum, dParam,ma);
m_Param.SetParam(dParam,ma,nCol);
UpDataCurve(GetCurve(nCol),dParam,ma);
UpDataMaxFLow(dx,nNum);
}
// Masks don't need to be validated as all characters do something
DataSource * DSMasked :: FromXML( const ALib::XMLElement * e ) {
ForbidChildren( e );
RequireAttrs( e, MASK_ATTRIB );
AllowAttrs( e, AttrList( MASK_ATTRIB, ORDER_ATTRIB, 0 ) );
string mask = e->AttrValue( MASK_ATTRIB );
return new DSMasked( GetOrder( e ), mask );
}
void FbAuthListThread::DoLetter(FbSQLite3Database &database)
{
wxString sql = wxT("SELECT id, full_name FROM authors");
sql << GetJoin();
if (m_info.m_letter) sql << wxT("WHERE letter=?");
sql << GetOrder();
FbSQLite3Statement stmt = database.PrepareStatement(sql);
if (m_info.m_letter) stmt.Bind(1, (wxString)m_info.m_letter);
FbSQLite3ResultSet result = stmt.ExecuteQuery();
MakeModel(result);
}
void FbAuthListThread::DoFullText(FbSQLite3Database &database)
{
wxString sql = wxT("SELECT docid, full_name FROM fts_auth INNER JOIN authors ON id=docid");
sql << GetJoin();
sql << wxT("WHERE fts_auth MATCH ?");
sql << GetOrder();
FbSQLite3Statement stmt = database.PrepareStatement(sql);
stmt.FTS(1, m_info.m_string);
FbSQLite3ResultSet result = stmt.ExecuteQuery();
MakeModel(result);
}
void FbAuthListThread::DoString(FbSQLite3Database &database)
{
wxString sql = wxT("SELECT id, full_name FROM authors");
sql << GetJoin();
sql << wxT("WHERE SEARCH(full_name)");
sql << GetOrder();
FbSearchFunction search(m_info.m_string);
database.CreateFunction(wxT("SEARCH"), 1, search);
FbSQLite3ResultSet result = database.ExecuteQuery(sql);
MakeModel(result);
}
DataSource * DSCase :: FromXML( const ALib::XMLElement * e ) {
if ( e->Parent() == 0 || e->Parent()->Name() != SELECT_TAG ) {
XMLERR( e, "case must be part of select" );
}
AllowAttrs( e, AttrList( ORDER_ATTRIB, VALUES_ATTR, 0 ) );
RequireChildren( e );
string values = e->AttrValue( VALUES_ATTR, "" );
std::auto_ptr <DSCase> cs( new DSCase( GetOrder( e ), values ) );
cs->AddChildSources( e );
return cs.release();
}
// unique supports the following attributes:
// order - usual stuff
// fields - list of fields to consider for uniqueness
// retry - number of time sto retry getting unique row
DataSource * DSUnique :: FromXML( const ALib::XMLElement * e ) {
RequireChildren( e );
AllowAttrs( e, AttrList( ORDER_ATTRIB,FIELDS_ATTRIB, RETRY_ATTRIB, 0 ) );
string fl = e->AttrValue( FIELDS_ATTRIB, "" );
FieldList cmpf( fl );
int retry = GetInt( e, RETRY_ATTRIB, ALib::Str( UNIQUE_RETRY) );
if ( retry < 0 ) {
throw XMLError( ALib::SQuote( RETRY_ATTRIB ) + " cannot be negative", e );
}
std::auto_ptr <DSUnique> c( new DSUnique( GetOrder( e ), cmpf , retry ));
c->AddChildSources( e );
return c.release();
}
void Game::Start(int Round)
{
for(int i=1;i<=Round;i++)
{
double Max=0;
int Luck=0;
Packet RedPacket(PacketMoney,PacketQuota);
GetOrder();
for(int j=1;j<=PacketQuota;j++)
{
double Get=RedPacket.GetMoney();
int Index=Order[j];
Money[Index]+=Get;
}
Luck=Debug.Statistics(Money,PacketMoney);
Money[Luck]-=PacketMoney;
}
}
void JapaneseContextAnalysis::HandleData(const char* aBuf, PRUint32 aLen)
{
PRUint32 charLen;
PRInt32 order;
PRUint32 i;
if (mDone)
return;
//The buffer we got is byte oriented, and a character may span in more than one
//buffers. In case the last one or two bytes in the last buffer is not complete, we
//record how many bytes are needed to complete that character and skip those bytes here.
//We can choose to record those bytes as well and analyze the character once it
//is complete, but since a character will not make much difference, by skipping
//this character we will simplify our logic and improve performance.
for (i = mNeedToSkipCharNum; i < aLen; )
{
order = GetOrder(aBuf+i, &charLen);
i+= charLen;
if (i > aLen){
mNeedToSkipCharNum = i - aLen;
mLastCharOrder = -1;
}
else
{
if (order != -1 && mLastCharOrder != -1)
{
mTotalRel ++;
if (mTotalRel > MAX_REL_THRESHOLD)
{
mDone = PR_TRUE;
break;
}
mRelSample[int(jp2CharContext[mLastCharOrder][order])]++;
}
mLastCharOrder = order;
}
}
return;
}
bool BulletLauncher::Shoot()
{
// 如果标记可以射击才会发射出子弹
if (_bShoot)
{
Bullet* bullet = CreateBullet();
bullet->SetPosition(
GetPositionX(),
GetPositionY(),
GetPositionZ());
bullet->SetAngleZ(GetAngleZ());
bullet->SetDirectionAngle(GetAngleZ());
bullet->SetOrder(GetOrder());
_belongPlane->GetScene()->Add(bullet);
// 发射过了,标记为不可发射
_bShoot = false;
return true;
}
return false;
}
void VQModel::Init()
{
if (mClusterCentroids.size() != GetOrder())
{
mClusterCentroids.resize(GetOrder());
}
if (mClusterSizes.size() != GetOrder())
{
mClusterSizes.resize(GetOrder());
}
if (mClusterWeights.size() != GetOrder())
{
mClusterWeights.resize(GetOrder());
}
}
bool IntegerGroup::IsGenerator(const Element &a) const
{
return IsElement(a)
&& ((Exponentiate(a, GetOrder()) == GetIdentity()))
&& (!(Exponentiate(a, Integer(2)) == GetIdentity()));
}
Integer CppECGroup::RandomExponent() const
{
return CryptoRandom().GetInteger(1, GetOrder(), false);
}
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
Data data;
mxArray *Im;
int nof_dim;
const int *elem_per_dim;
int nargout;
int i;
// set default values
SetDefaults(&data);
// check number of input arguments
if( (nrhs % 2 == 0) || (nrhs < 3 ) )
{
ErrorMessage(ERR_NARGIN);
ClearMemory(&data);
return;
}
// initialize that part of the data depending only on input image
{
if( !mxIsDouble(prhs[0]) ) // check if image is given as double
{
ErrorMessage(ERR_DOUBLE);
ClearMemory(&data);
return;
}
// get image dimensions
nof_dim = mxGetNumberOfDimensions(prhs[0]);
elem_per_dim = mxGetDimensions(prhs[0]);
if( nof_dim > 3 )
{
ErrorMessage(ERR_DIM);
ClearMemory(&data);
return;
}
plhs[0] = mxDuplicateArray(prhs[0]); // output image
Im = mxDuplicateArray(prhs[0]); // smoothed image
data.rows = elem_per_dim[0];
data.cols = elem_per_dim[1];
data.size = data.rows * data.cols;
data.channels = 1;
if( nof_dim == 3 )
data.channels = elem_per_dim[2];
data.Image = mxGetPr(plhs[0]);
data.MImage = mxGetPr(Im);
data.Ihelp = (double *)AllocMem(sizeof(double) * data.channels);
data.Tfield = (hItem *) AllocMem(sizeof(hItem) * data.size);
data.Domain = (double *) AllocMem(sizeof(double) * data.size);
data.MDomain = (double *) AllocMem(sizeof(double) * data.size);
data.heap = (hItem **) AllocMem(sizeof(hItem *) * data.size);
data.ordered_points = (double *) AllocMem(sizeof(double) * data.size *3);
// number of output arguments
if( nlhs <= 2 )
nargout = nlhs;
else
nargout = 2;
}
// get and check arguments
{
char guidance_done = 0;
char order_done = 0;
char argname[100];
int len;
int err;
for( i = 1 ; i < nrhs ; i = i+2 )
{
if( !mxIsChar( prhs[i] ) )
{
ErrorMessage(ERR_STRING);
ClearMemory(&data);
return;
}
else
{
len = mxGetN( prhs[i] );
mxGetString( prhs[i], argname, len+1);
//mexPrintf(" %s \n", argname);
switch( argname[0] )
{
case 'o': // orderD , orderT
{
if( !order_done )
{
if( !mxIsEmpty(prhs[i+1]) )
{
if( argname[len-1] == 'D' )
{
err = GetMask( prhs[i+1], &data);
data.ordergiven = 0;
}
else if( argname[len-1] == 'T' )
{
err = GetOrder( prhs[i+1], &data);
data.ordergiven =1;
}
else
err = ERR_UNKNOWN_ID;
}
else
err = ERR_ARG_MISSING;
order_done = 1;
}
break;
}
case 'g': // guidanceN , guidanceC , guidanceD
{
if( !guidance_done )
{
if( !mxIsEmpty(prhs[i+1]) )
{
if( argname[len-1] == 'N' )
{
err = GetParam( prhs[i+1], &data, TYPE_N);
data.guidance = 0;
}
else if( argname[len-1] == 'C' )
{
err = GetParam( prhs[i+1], &data, TYPE_C);
data.guidance = 1;
}
else if( argname[len-1] == 'D' )
{
err = GetParam( prhs[i+1], &data, TYPE_D);
data.guidance = 2;
}
else
err = ERR_UNKNOWN_ID;
}
else
err = ERR_ARG_MISSING;
// guidance_done = 1;
if(data.GivenGuidanceT != NULL)
data.guidance = 2;
}
break;
}
default:
err = ERR_UNKNOWN_ID;
break;
}
if( err )
{
ErrorMessage(err);
ClearMemory(&data);
return;
}
}
}
if( !order_done ) // at least mask must be specified
{
ErrorMessage(ERR_NO_MASK_ORDER);
ClearMemory(&data);
return;
}
}
if( data.guidance == 1)
SetKernels(&data);
InpaintImage(&data);
if(data.inpaint_undefined == 1)
{
mexPrintf("\n\n");
mexPrintf("Error:\n");
mexPrintf("Some inpainted image values are undefined !\n");
mexPrintf("This happens if the order is not well-defined. \n");
mexPrintf("You can find out the undefined pixels by: > ind = find( isnan(result) ) \n\n\n");
}
if( nargout == 2 )
{
double *p;
int size;
size = 3 * data.nof_points2inpaint;
plhs[1] = mxCreateDoubleMatrix(3, data.nof_points2inpaint , mxREAL);
p = mxGetPr(plhs[1]);
for( i=0 ; i < size ; i++ )
if( (i+1) % 3 != 0 )
p[i] = data.ordered_points[i] + 1;
else
p[i] = data.ordered_points[i];
}
//CopyMask(&data);
//CopyParam( &data );
//CopyDirfield( &data );
//CopyMImage( &data );
//CopyTfield(&data);
ClearMemory(&data);
return;
}
int InputInteractionComponent::GetOrder() const
{
auto renderer = m_GameObject->GetComponent<RendererComponent>();
return renderer != nullptr ? renderer->GetOrder() : 0;
}
void VQModel::Adapt(const std::shared_ptr<Model>& other, const std::vector< DynamicVector<Real> >& samples,
unsigned int iterations, Real relevanceFactor)
{
const VQModel* model = dynamic_cast<VQModel*>(other.get());
if (model == nullptr)
{
std::cout << "Not VQModel." << std::endl;
return;
}
SetOrder(model->GetOrder());
Init();
std::vector<unsigned int> indices(samples.size());
// Initialize the feature vectors of the centroids.
for (unsigned int c = 0; c < GetOrder(); c++)
{
mClusterCentroids[c] = model->mClusterCentroids[c];
}
// Do the iterations.
for (unsigned int i = 0; i < iterations; i++)
{
//Find the closest centroid to each sample
for (unsigned int n = 0; n < samples.size(); n++)
{
Real minDist = std::numeric_limits<Real>::max();
for (unsigned int c = 0; c < GetOrder(); c++)
{
Real dist = samples[n].Distance(mClusterCentroids[c]);
if (dist < minDist)
{
minDist = dist;
indices[n] = c;
}
}
}
//Set the centroids to the average of the samples in each centroid
for (unsigned int c = 0; c < GetOrder(); ++c)
{
mClusterCentroids[c].Assign(0.0f);
mClusterSizes[c] = 0;
}
for (unsigned int s = 0; s < samples.size(); ++s)
{
mClusterCentroids[indices[s]].Add(samples[s]);
++mClusterSizes[indices[s]];
}
for (unsigned int c = 0; c < GetOrder(); ++c)
{
if (mClusterSizes[c] > 0)
{
mClusterCentroids[c].Multiply(1.0f / static_cast<Real>(mClusterSizes[c]));
}
}
//Calculate the adapted values
for (unsigned int c = 0; c < GetOrder(); ++c)
{
Real size = static_cast<Real>(mClusterSizes[c]);
Real w = size / (size + static_cast<Real>(relevanceFactor));
DynamicVector<Real> ubmc = model->mClusterCentroids[c];
ubmc.Multiply(1.0f - w);
mClusterCentroids[c].Multiply(w);
mClusterCentroids[c].Add(ubmc);
}
}
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { ALLOCATES();
real *X, XX[NN], Xk[NN], XXr[NN], D[N], DS[N], fD[N], V[NN], VS[NN], *O, Ok[NN];
long k1, K1, k2, K2, k3, K3, ii, jj;
int ORDER[N];
char STR[100];
enum symmetrize_ { NONE , X_Xt , Xt_X , PLUS };
enum symmetrize_ symmetrize;
enum outs_types { ID , INVERSE , EIGVALS , EIGVECS , EIGVALSDIAG , MAXDIFF , SQRT , LOG , EXP , evalFUN , DET , TRACE };
enum outs_types outs[50];
int ndims, Odims[50];
real det;
int oid;
int D_computed, V_computed, D_sorted, V_sorted, ORDER_computed;
int dim1 , dim2;
mxArray *mxX;
if( nlhs == 0 ){ nlhs = 1; }
if( nlhs > nrhs-2 ){
myErrMsgTxt("There are no enough inputs.\n");
}
if( mxIsCell( prhs[0] ) ){
mxX = mxGetCell( prhs[0] , 0 );
dim1 = myGetValue( mxGetCell( prhs[0] , 1 ) );
dim2 = myGetValue( mxGetCell( prhs[0] , 2 ) );
} else {
mxX = prhs[0];
dim1 = 1;
dim2 = 2;
}
if( ( mySize( mxX , dim1-1 ) != N ) || ( mySize( mxX , dim1-1 ) != N ) ){
myErrMsgTxt("size( X , %d ) and size( X , %d ) have to be equal to three.\n",dim1,dim2);
}
if( myIsEmpty( prhs[1] ) ){
symmetrize = NONE;
} else if( mxIsChar(prhs[1]) ){
mxGetString( prhs[1], STR, 100 );
if( !myStrcmpi(STR,"+") ) {
symmetrize = PLUS;
} else if( !myStrcmpi(STR,"xt*x") || !myStrcmpi(STR,"xtx") ) {
symmetrize = Xt_X;
} else if( !myStrcmpi(STR,"x*xt") || !myStrcmpi(STR,"xxt") ) {
symmetrize = X_Xt;
} else {
myErrMsgTxt("Second argument expected: 'xt*x' , 'x*xt' , '+' , or [].\n");
}
} else {
myErrMsgTxt("Second argument expected: 'xt*x' , 'x*xt' , '+' , or [].\n");
}
for( oid = 0 ; oid < nlhs ; oid++ ){
if( ! mxIsChar(prhs[oid+2]) ){
myErrMsgTxt("Valids arguments are: 'id' 'eigval' 'eigvec' 'log' 'sqrt' 'exp' 'error'.\n");
}
mxGetString( prhs[oid+2], STR, 100 );
if( !myStrcmpi(STR,"id") ) {
outs[oid] = ID;
} else if( !myStrcmpi(STR,"inv") || !myStrcmpi(STR,"inverse") ) {
outs[oid] = INVERSE;
} else if( !myStrcmpi(STR,"det") ) {
outs[oid] = DET;
} else if( !myStrcmpi(STR,"trace") ) {
outs[oid] = TRACE;
} else if( !myStrcmpi(STR,"evec") || !myStrcmpi(STR,"v") || !myStrcmpi(STR,"eigenvec") || !myStrcmpi(STR,"eigvec") || !myStrcmpi(STR,"eigenvectors") ) {
outs[oid] = EIGVECS;
} else if( !myStrcmpi(STR,"eval") || !myStrcmpi(STR,"d") || !myStrcmpi(STR,"eigenval") || !myStrcmpi(STR,"eigval") || !myStrcmpi(STR,"eigenvalues") ) {
outs[oid] = EIGVALS;
} else if( !myStrcmpi(STR,"diag") || !myStrcmpi(STR,"dd") ) {
outs[oid] = EIGVALSDIAG;
} else if( !myStrcmpi(STR,"error") ) {
outs[oid] = MAXDIFF;
} else if( !myStrcmpi(STR,"sqrt") || !myStrcmpi(STR,"sqrtm") ) {
outs[oid] = SQRT;
} else if( !myStrcmpi(STR,"log") || !myStrcmpi(STR,"logm") ) {
outs[oid] = LOG;
} else if( !myStrcmpi(STR,"exp") || !myStrcmpi(STR,"expm") ) {
outs[oid] = EXP;
} else {
myErrMsgTxt("Valids arguments are: 'id' 'inv' 'det' 'trace' 'eigval' 'eigvec' 'log' 'sqrt' 'exp' 'error'.\n");
}
}
X = mxGetPr( mxX );
ndims = myGetSizes( mxX , Odims );
for( oid = 0 ; oid < nlhs ; oid++ ){
switch( outs[oid] ){
case ID:
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
break;
case INVERSE:
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
break;
case DET:
Odims[dim1-1] = 1;
Odims[dim2-1] = 1;
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
Odims[dim1-1] = N;
Odims[dim2-1] = N;
break;
case TRACE:
Odims[dim1-1] = 1;
Odims[dim2-1] = 1;
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
Odims[dim1-1] = N;
Odims[dim2-1] = N;
break;
case EIGVALS:
Odims[dim2-1] = 1;
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
Odims[dim2-1] = N;
break;
case EIGVECS:
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
break;
case EIGVALSDIAG:
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
break;
case MAXDIFF:
Odims[dim1-1] = 1;
Odims[dim2-1] = 1;
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
Odims[dim1-1] = N;
Odims[dim2-1] = N;
break;
case EXP:
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
break;
case LOG:
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
break;
case SQRT:
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
break;
case evalFUN:
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
break;
}
}
K1 = 1;
for( k1 = 0 ; k1 < dim1-1 ; k1++ ){ K1 *= Odims[k1]; }
K2 = 1;
for( k2 = dim1 ; k2 < dim2-1 ; k2++ ){ K2 *= Odims[k2]; }
K3 = 1;
for( k3 = dim2 ; k3 < ndims ; k3++ ){ K3 *= Odims[k3]; }
for( k3 = 0 ; k3 < K3 ; k3++ ){
for( k2 = 0 ; k2 < K2 ; k2++ ){
for( k1 = 0 ; k1 < K1 ; k1++ ){
if( K1 == 1 && K2 == 1 ){
memcpy( Xk , X + k3*NN , NN*sizeof( real ) );
} else {
for( jj = 0 ; jj < N ; jj++ ){ for( ii = 0 ; ii < N ; ii++ ){
Xk[ ii + N*jj ] = X[ k1 + K1*( ii + N*( k2 + K2*( jj + N*k3 ))) ];
} }
}
switch( symmetrize ){
case NONE:
memcpy( XX , Xk , NN*sizeof( real ) );
break;
case X_Xt:
XX[0] = Xk[0]*Xk[0] + Xk[2]*Xk[2];
XX[1] = Xk[1]*Xk[0] + Xk[3]*Xk[2];
XX[2] = Xk[0]*Xk[1] + Xk[2]*Xk[3];
XX[3] = Xk[1]*Xk[1] + Xk[3]*Xk[3];
break;
case Xt_X:
XX[0] = Xk[0]*Xk[0] + Xk[1]*Xk[1];
XX[1] = Xk[2]*Xk[0] + Xk[3]*Xk[1];
XX[2] = Xk[0]*Xk[2] + Xk[1]*Xk[3];
XX[3] = Xk[2]*Xk[2] + Xk[3]*Xk[3];
break;
case PLUS:
XX[0] = Xk[0];
XX[1] = XX[2] = ( Xk[1] + Xk[2] )/2.0;
XX[3] = Xk[3];
break;
}
D_computed = 0;
V_computed = 0;
ORDER_computed = 0;
D_sorted = 0;
V_sorted = 0;
for( oid = 0 ; oid < nlhs ; oid++ ){
switch( outs[oid] ){
case ID:
memcpy( Ok , XX , NN*sizeof( real ) );
O = mxGetPr( plhs[oid] );
ToOutput2x2;
break;
case INVERSE:
det = XX[0]*XX[3] - XX[1]*XX[2];
det = 1.0/det;
Ok[0] = XX[3] *det;
Ok[1] = -XX[1] *det;
Ok[2] = -XX[2] *det;
Ok[3] = XX[0] *det;
O = mxGetPr( plhs[oid] );
ToOutput2x2;
break;
case DET:
Ok[0] = XX[0]*XX[3] - XX[1]*XX[2];
O = mxGetPr( plhs[oid] );
ToOutput1x1;
break;
case TRACE:
Ok[0] = XX[0] + XX[3];
O = mxGetPr( plhs[oid] );
ToOutput1x1;
break;
case EIGVALS:
if( !D_computed ){ EigenValues2x2( XX , D ); D_computed = 1; }
if( !ORDER_computed ){ GetOrder( D, ORDER ); ORDER_computed = 1; }
if( !D_sorted ){ SortEigenValues( D, ORDER , DS ); D_sorted = 1; }
memcpy( Ok , DS , N*sizeof( real ) );
O = mxGetPr( plhs[oid] );
ToOutput2x1;
break;
case EIGVALSDIAG:
if( !D_computed ){ EigenValues2x2( XX , D ); D_computed = 1; }
if( !ORDER_computed ){ GetOrder( D, ORDER ); ORDER_computed = 1; }
if( !D_sorted ){ SortEigenValues( D, ORDER , DS ); D_sorted = 1; }
Ok[0] = DS[0];
Ok[3] = DS[1];
Ok[1] = Ok[2] = 0;
O = mxGetPr( plhs[oid] );
ToOutput2x2;
break;
case EIGVECS:
if( !D_computed ){ EigenValues2x2( XX , D ); D_computed = 1; }
if( !V_computed ){ EigenVectors2x2( XX , D , V); V_computed = 1; }
if( !ORDER_computed ){ GetOrder( D, ORDER ); ORDER_computed = 1; }
if( !V_sorted ){ SortEigenVectors( V, ORDER , VS); V_sorted = 1; }
memcpy( Ok , VS , NN*sizeof( real ) );
O = mxGetPr( plhs[oid] );
ToOutput2x2;
break;
// case MAXDIFF:
// if( !D_computed ){ EigenValuesSym3x3( XX , D ); D_computed = 1; }
// if( !V_computed ){ EigenVectorsSym3x3( XX , D , V); V_computed = 1; }
//
// Ok[0] = V[0]*V[0]*D[0] + V[3]*V[3]*D[1] + V[6]*V[6]*D[2];
// Ok[1] = V[1]*V[0]*D[0] + V[4]*V[3]*D[1] + V[7]*V[6]*D[2];
// Ok[2] = V[2]*V[0]*D[0] + V[5]*V[3]*D[1] + V[8]*V[6]*D[2];
//
// Ok[3] = V[0]*V[1]*D[0] + V[3]*V[4]*D[1] + V[6]*V[7]*D[2];
// Ok[4] = V[1]*V[1]*D[0] + V[4]*V[4]*D[1] + V[7]*V[7]*D[2];
// Ok[5] = V[2]*V[1]*D[0] + V[5]*V[4]*D[1] + V[8]*V[7]*D[2];
//
// Ok[6] = V[0]*V[2]*D[0] + V[3]*V[5]*D[1] + V[6]*V[8]*D[2];
// Ok[7] = V[1]*V[2]*D[0] + V[4]*V[5]*D[1] + V[7]*V[8]*D[2];
// Ok[8] = V[2]*V[2]*D[0] + V[5]*V[5]*D[1] + V[8]*V[8]*D[2];
//
// Ok[0] = MAX9( fabs( Ok[0] - XX[0] ) ,
// fabs( Ok[1] - XX[1] ) ,
// fabs( Ok[2] - XX[2] ) ,
// fabs( Ok[3] - XX[3] ) ,
// fabs( Ok[4] - XX[4] ) ,
// fabs( Ok[5] - XX[5] ) ,
// fabs( Ok[6] - XX[6] ) ,
// fabs( Ok[7] - XX[7] ) ,
// fabs( Ok[8] - XX[8] ) );
//
// O = mxGetPr( plhs[oid] );
// ToOutput1x1;
// break;
//
//
// case SQRT:
// if( !D_computed ){ EigenValuesSym3x3( XX , D ); D_computed = 1; }
// if( !V_computed ){ EigenVectorsSym3x3( XX , D , V); V_computed = 1; }
//
// fD[0] = sqrt( D[0] );
// fD[1] = sqrt( D[1] );
// fD[2] = sqrt( D[2] );
//
// FillOk;
// O = mxGetPr( plhs[oid] );
// ToOutput3x3;
// break;
//
//
// case LOG:
// if( !D_computed ){ EigenValuesSym3x3( XX , D ); D_computed = 1; }
// if( !V_computed ){ EigenVectorsSym3x3( XX , D , V); V_computed = 1; }
//
// fD[0] = log( D[0] );
// fD[1] = log( D[1] );
// fD[2] = log( D[2] );
//
// FillOk;
// O = mxGetPr( plhs[oid] );
// ToOutput3x3;
// break;
#define r eval[0]
#define e eval[1]
#define er eval[2]
case EXP:
r = XX[0] - XX[3];
r = 4*XX[1]*XX[2] + r*r;
if( r >= 0 ){
r = sqrt(r);
e = exp( ( XX[0] + XX[3] - r )/2 )/r/2.0;
er = exp(r);
Ok[0] = e * ( XX[3] - XX[0] + r + er*(XX[0]-XX[3]+r) );
Ok[1] = e * XX[1] * ( er - 1 ) * 2;
Ok[2] = e * XX[2] * ( er - 1 ) * 2;
Ok[3] = e * ( XX[0] - XX[3] + r + er*(XX[3]-XX[0]+r) );
} else {
r = sqrt( -r );
e = exp( ( XX[0] + XX[3] )/2 )/r;
er = sin(r/2);
Ok[0] = e * ( r*cos(r/2) + ( XX[0]-XX[3] )*er );
Ok[1] = 2 * XX[1] * e * er;
Ok[2] = 2 * XX[2] * e * er;
Ok[3] = e * ( r*cos(r/2) + ( XX[3]-XX[0] )*er );
}
O = mxGetPr( plhs[oid] );
ToOutput2x2;
break;
// case evalFUN:
// O = mxGetPr( plhs[oid] ) + k*NN;
// if( !D_computed ){ EigenValuesSym3x3( XX , D ); D_computed = 1; }
// if( !V_computed ){ EigenVectorsSym3x3( XX , D , V); V_computed = 1; }
//
// fD[0] = exp( D[0] );
// fD[1] = exp( D[1] );
// fD[2] = exp( D[2] );
//
// mexCallMATLAB(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[], const char *name)
//
// FillO
// break;
}
}
}}}
EXIT: myFreeALLOCATES();
}
Integer PairingGroup::RandomExponent() const
{
return Integer::GetRandomInteger(1, GetOrder(), false);
}
