void DeltaPosition(int& dx, int& dy)
{
if (dx != 0 || dy != 0) {
//ZDebugOutput("MouseMove: (" + ZString(dx) + ", " + ZString(dy) + ")\n");
m_point.SetX(m_point.X() + CalculateDelta(dx));
m_point.SetY(m_point.Y() - CalculateDelta(dy));
dx = 0;
dy = 0;
//
// Clip to the screen rect if required
//
DoClip();
//
// Update outputs
//
m_vvalueObject[0]->GetValue()->SetValue(m_point.X());
m_vvalueObject[1]->GetValue()->SetValue(m_point.Y());
}
}
ppInt32 CosArrayInsert( PDFCosHandle CosObject, PDFCosHandle NewCosObject, ppUns32 Position )
{
if ( !_IsCosArray( CosObject ) )
_RAISE ( ErrCosLevel, cleInvalidObjError );
if ( _CosDoc ( NewCosObject ) != _DOC )
_RAISE ( ErrCosLevel, cleCannotInsertObjectFromOtherDocumentError );
if ( !_CosIsIndirect ( NewCosObject) && _CosParent ( NewCosObject ) )
_RAISE ( ErrCosLevel, cleCannotInsertObjectWithParrentError );
if ( Position >= _CosArrayCount ( CosObject ) )
return CosArrayAppend ( CosObject, NewCosObject );
if ( _CosArrayCount ( CosObject ) == _CosArrayCapacity ( CosObject ) ){
_CosArrayCapacity ( CosObject ) += CalculateDelta ( _CosArrayCapacity ( CosObject ) );
_CosArrayArray ( CosObject ) = ( PDFCosHandle * )
mrealloc ( _LIB, _CosArrayArray ( CosObject ),
_CosArrayCapacity ( CosObject ) * sizeof ( PDFCosHandle ) );
};
memmove ( &( _CosArrayItem ( CosObject, Position + 1 ) ),
&( _CosArrayItem ( CosObject, Position ) ),
( _CosArrayCount ( CosObject ) - Position ) * sizeof ( PDFCosHandle ) );
if ( _CosIsIndirect ( NewCosObject ) )
NewCosObject = CosNewRef ( _CosDoc( NewCosObject ), _CosObjID ( NewCosObject),
_CosObjGeneration ( NewCosObject ) );
_CosArrayItem ( CosObject, Position ) = NewCosObject;
_CosArrayCount ( CosObject )++;
if ( !_IsCosNull ( NewCosObject ) )
_CosParent ( NewCosObject ) = CO ( CosObject );
return Position;
}
// Calculating the new volatility as per the Glicko2 system.
float Glicko2::newVolatility(Player &player, const std::vector<Match> &matches, const float v)
{
// Step 4
const float delta = CalculateDelta(player, matches, v);
// Step 5
// 5.1
const float a = log(pow(player.volatility, 2));
auto f = [=](float x)
{
return exp(x) * (pow(delta, 2) -pow(player.deviation, 2) - v - exp(x)) / (2 * pow(pow(player.deviation, 2) + v + exp(x), 2)) - (x - a) / pow(tau, 2);
};
// 5.2
float A = a;
float B, k;
if (pow(delta, 2) > pow(player.deviation, 2) + v)
{
B = log(pow(delta, 2) - pow(player.deviation, 2) - v);
}
else
{
k = 1.0f;
while (f(a - k * tau) < 0)
{
k = k + 1;
}
B = a - k * tau;
}
// 5.3
float fA = f(A);
float fB = f(B);
float C, fC;
// 5.4
while (abs(B - A) > epsilon)
{
C = A + (A - B) * fA / (fB - fA);
fC = f(C);
if (fC * fB < 0)
{
A = B;
fA = fB;
}
else
{
fA = fA / 2;
}
B = C;
fB = fC;
}
// 5.5
return exp(A/2);
}
//===============================================================================================
BufferDelta::BufferDelta(char* baseBuffer, char* diffBuffer, size_t numBytes)
{
#if defined(VERIFY_DELTA_RESULTS) || !defined(APPLY_DELTA)
m_copiedDiffBuffer = NULL;
#endif // defined(VERIFY_DELTA_RESULTS) || !defined(APPLY_DELTA)
#ifndef USE_VECTOR_FOR_DATA
m_pDiffs = NULL;
#endif
CalculateDelta(baseBuffer, diffBuffer, numBytes);
}
void CosDictAppend(PDFCosHandle CosObject, ppAtom Key, PDFCosHandle KeyValue )
{
ppUns32 i;
if ( !_IsCosDictOrStream (CosObject) )
_RAISE ( ErrCosLevel, cleInvalidObjError );
if ( _CosDoc ( KeyValue ) != _DOC )
_RAISE ( ErrCosLevel, cleCannotInsertObjectFromOtherDocumentError );
if ( !_CosIsIndirect ( KeyValue) && _CosParent ( KeyValue ) )
_RAISE ( ErrCosLevel, cleCannotInsertObjectWithParrentError );
if ( _IsCosNull ( KeyValue ) ){
CosDictRemoveKey ( CosObject, Key );
return;
}
if ( _IsCosStream ( CosObject ) )
CosObject = _CosStreamAttr (CosObject );
/* Check on exists key */
for ( i = 0; i < _CosDictCount ( CosObject ); i++ )
if ( _CosDictKey ( CosObject, i) == Key ){
CosFree( _CosDictValue ( CosObject, i) );
if ( _CosIsIndirect ( KeyValue ) )
KeyValue = CosNewRef ( _CosDoc( KeyValue ), _CosObjID ( KeyValue),
_CosObjGeneration ( KeyValue ) );
_CosDictValue ( CosObject, i) = KeyValue;
_CosParent ( KeyValue ) = CO ( CosObject );
return;
};
if ( _CosDictCount ( CosObject ) == _CosDictCapacity (CosObject) ){
_CosDictCapacity ( CosObject ) += CalculateDelta ( _CosDictCapacity ( CosObject) );
_CosDictArray ( CosObject ) = ( DictElem * ) mrealloc ( _LIB, _CosDictArray ( CosObject ),
_CosDictCapacity ( CosObject) * sizeof ( DictElem ) );
}
i = _CosDictCount ( CosObject );
_CosDictKey ( CosObject, i) = Key;
if ( _CosIsIndirect ( KeyValue ) )
KeyValue = CosNewRef ( _CosDoc( KeyValue ), _CosObjID ( KeyValue),
_CosObjGeneration ( KeyValue ) );
_CosDictValue ( CosObject, i) = KeyValue;
_CosParent ( KeyValue ) = CO ( CosObject );
_CosDictCount ( CosObject )++;
}
ppInt32 ULModFindOrAppendAtom(PDFLibHandle Lib, char *str)
{
PPDFLib l = ( PPDFLib ) Lib;
ppInt32 i, cmp;
char *n;
PppAtomNode /* T = &( l-> AtomRoot), */
S,P, Q;
S = P = l->AtomRoot.Right;
if ( !S ){
S = ( PppAtomNode ) mmalloc ( Lib, sizeof ( ppAtomNode ) );
i = ( ppInt32 ) strlen ( str );
n = ( char * ) mmalloc ( Lib, i + 1 );
memcpy ( n, str, i + 1 );
S->Balance = 0;
S->ID = 0;
S->Left = NULL;
S->Right = NULL;
S->String = n;
S->EscStr = ULGetEscName ( Lib, n );
S->Length = ULGetNameSize ( n );
if ( ( l->AtomCount ) == l->AtomCapacity ){
l->AtomCapacity += CalculateDelta(l->AtomCapacity);
l->AtomArray = ( PppAtomNode *) mrealloc ( Lib, l->AtomArray, sizeof ( PppAtomNode ) * l->AtomCapacity );
};
l->AtomArray[l->AtomCount++] = S;
l->AtomRoot.Right = S;
return 0;
}
A2 :
cmp = strcmp ( str, P->String );
if ( !cmp )
return P->ID;
if ( cmp < 0 ){
Q = P->Left;
if ( !Q ){
Q = ( PppAtomNode ) mmalloc ( Lib, sizeof ( ppAtomNode ) );
P->Left = Q;
goto A5;
}
} else{
Q = P->Right;
if ( !Q ){
Q = ( PppAtomNode )mmalloc ( Lib, sizeof ( ppAtomNode ) );
P->Right = Q;
goto A5;
}
}
/* if ( Q->Balance ){
T = P;
S = Q;
}*/
P = Q;
goto A2;
A5 :
i = ( ppInt32 ) strlen ( str );
n = ( char * ) mmalloc ( Lib, i + 1 );
memcpy ( n, str, i + 1 );
Q->Balance = 0;
Q->ID = l->AtomCount;
Q->Left = NULL;
Q->Right = NULL;
Q->String = n;
Q->EscStr = ULGetEscName ( Lib, n );
Q->Length = ULGetNameSize ( n );
if ( ( l->AtomCount ) == l->AtomCapacity ){
l->AtomCapacity += CalculateDelta ( l->AtomCapacity ) ;
l->AtomArray = ( PppAtomNode * )mrealloc ( Lib, l->AtomArray, sizeof ( PppAtomNode ) * l->AtomCapacity );
};
l->AtomArray[l->AtomCount] = Q;
return l->AtomCount++;
}
OpenBabel::OBMol
Schuffenhauer::Rule_4(OpenBabel::OBMol& oldMol)
{
std::vector<OpenBabel::OBRing*> allrings(oldMol.GetSSSR());
if (allrings.size() <= _ringsToBeRetained)
{
return oldMol;
}
// Only focus on ringsystems with more than one ring
std::vector<OpenBabel::OBAtom*>::iterator avi;
std::vector<OpenBabel::OBMol> mols;
OpenBabel::OBAtom* atom;
std::vector<int> fusedRings;
for (unsigned int i(0); i < allrings.size(); ++i)
{
for (atom = oldMol.BeginAtom(avi); atom; atom = oldMol.NextAtom(avi))
{
if (allrings[i]->IsMember(atom) && (atom->MemberOfRingCount() > 1))
{
fusedRings.push_back(i);
mols.push_back(oldMol);
break;
}
}
}
if (fusedRings.empty())
{
return oldMol;
}
std::vector<OpenBabel::OBMol> validMols;
for (unsigned int i(0); i < fusedRings.size(); ++i)
{
mols[i] = RemoveRing(mols[i], allrings, fusedRings[i]);
if (!mols[i].Empty())
{
validMols.push_back(mols[i]);
}
}
if (validMols.empty())
{
return oldMol;
}
int delta;
int absdelta;
std::vector<int> score;
for (unsigned int i(0); i < validMols.size(); ++i)
{
delta = CalculateDelta(validMols[i]);
absdelta = abs(delta);
score.push_back(1000 * absdelta + delta);
}
int maximum = score[0];
for (unsigned int i(1); i < validMols.size(); ++i)
{
if (score[i] > maximum)
{
maximum = score[i];
}
}
unsigned int oldMolecules = validMols.size();
std::vector<OpenBabel::OBMol> remainingMols;
for (unsigned int i(0); i < validMols.size(); ++i)
{
if (score[i] == maximum)
{
remainingMols.push_back(validMols[i]);
}
}
if (remainingMols.size() == 1)
{
return remainingMols[0];
}
return oldMol;
}
