void dswapVector3(sparseVector *sparse1, sparseVector *sparse2, int indexStart, int indexEnd)
{
REAL *dense1, *dense2;
if(indexStart<=0)
indexStart = 1;
if(indexEnd<=0)
indexEnd = MAX(lastIndex(sparse1), lastIndex(sparse2));
if(indexStart <= firstIndex(sparse1) && indexStart <= firstIndex(sparse2) &&
indexEnd >= lastIndex(sparse1) && indexEnd >= lastIndex(sparse2)) {
swapVector(sparse1, sparse2);
}
else {
CALLOC(dense1, (indexEnd+1));
CALLOC(dense2, (indexEnd+1));
getVector(sparse1, dense1, indexStart, indexEnd, TRUE);
getVector(sparse2, dense2, indexStart, indexEnd, TRUE);
clearVector(sparse1, indexStart, indexEnd);
clearVector(sparse2, indexStart, indexEnd);
putVector(sparse1, dense2, indexStart, indexEnd);
putVector(sparse2, dense1, indexStart, indexEnd);
MEMFREE(dense1);
MEMFREE(dense2);
}
}
void Loop::reset()
{
mGui.clear();
initializeGui();
mDataStructure.deleteBoids();
mDataStructure.createRandBoid(PREGEN_BOIDS);
clearVector(mBlocks);
clearVector(mTriangles);
clearVector(mPathVertices);
mNeighborhoodGraph.clear();
mTimeScale = 1.0f;
mIsLeaderOn = false;
mLeader = 0;
mIsBoidVectorRendered = false;
mIsDelaunayRendered = true;
mIsDelaunayUpToDate = false;
mFood.setPosition(-10, -10);
mBoidRules.resetRules();
mPathFinish = Vector2(GUI_WIDTH + 30.0f, 30.0f);
updateBoidCounter();
mGui.updateElementContent(1, mBoidRules.setParameter(mBoidRules.SEPARATION, SEPARATION_DISTANCE));
mGui.updateElementContent(2, mBoidRules.setParameter(mBoidRules.COHESION, COHESION_DIVISOR));
mGui.updateElementContent(3, mBoidRules.setParameter(mBoidRules.ALIGNMENT, ALIGNMENT_DIVISOR));
mGui.updateElementContent(4, mTimeScale * 100);
mGui.print("");
}
status
unlinkVector(Vector v)
{ if ( v->elements != NULL )
return clearVector(v);
succeed;
}
static status
lowIndexVector(Vector v, Int low)
{ int l = valInt(low);
int ol = valInt(v->offset) + 1;
if ( l > ol ) /* too long */
{ int size = valInt(v->size) + valInt(v->offset) - l;
if ( size > 0 )
{ Any *elms = alloc(size * sizeof(Any));
fillVector(v, NIL, toInt(l), toInt(ol-1)); /* dereference */
cpdata(elms, &v->elements[l-ol], Any, size);
unalloc(valInt(v->allocated)*sizeof(Any), v->elements);
v->elements = elms;
assign(v, size, toInt(size));
assign(v, allocated, v->size);
succeed;
} else
{ return clearVector(v);
}
} else if ( l < ol ) /* too, short */
{ return fillVector(v, NIL, toInt(l), toInt(ol-1));
}
succeed;
}
static status
highIndexVector(Vector v, Int high)
{ int h = valInt(high);
int oh = valInt(v->offset) + valInt(v->size);
if ( oh > h ) /* too long */
{ int size = h - valInt(v->offset);
if ( size > 0 )
{ Any *elms = alloc(size * sizeof(Any));
fillVector(v, NIL, inc(high), DEFAULT); /* dereference */
cpdata(elms, v->elements, Any, size);
unalloc(valInt(v->allocated)*sizeof(Any), v->elements);
v->elements = elms;
assign(v, size, toInt(size));
assign(v, allocated, v->size);
succeed;
} else
{ return clearVector(v);
}
} else if ( oh < h ) /* too, short */
{ return fillVector(v, NIL, toInt(oh+1), inc(high));
}
succeed;
}
void dswapVector1(sparseVector *sparse, REAL *dense, int indexStart, int indexEnd)
{
int i, d, n;
REAL *x;
if(indexStart <= 0)
indexStart = 1;
n = lastIndex(sparse);
if(indexEnd <= 0)
indexEnd = n;
CALLOC(x, (MAX(indexEnd,n)+1));
getVector(sparse, x, indexStart, n, FALSE);
d = getDiagonalIndex(sparse);
clearVector(sparse, indexStart, n);
for(i = indexStart; i<=indexEnd; i++) {
if(dense[i] != 0)
putItem(sparse, i, dense[i]);
}
for(i = indexEnd+1; i<=n; i++) {
if(x[i] != 0)
putItem(sparse, i, x[i]);
}
MEMCOPY(&dense[indexStart], &x[indexStart], (indexEnd-indexStart+1));
#ifdef DEBUG_SPARSELIB
verifyVector(sparse);
#endif
MEMFREE(x);
}
vector<vector<int> > combinationSum(vector<int> &candidates, int target) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
std::sort(candidates.begin(),candidates.end());
vector<int>tmp;clearVector(rs);this->candidates=candidates;
this->target=target;
dfs(tmp,0,0);
return rs;
}
void fillVector(sparseVector *sparse, int count, REAL value)
{
int i;
if(sparse->count > 0)
clearVector(sparse, 0, 0);
for(i = 1; i<=count; i++)
putItem(sparse, i, value);
}
void Loop::findPath()
{
//Run triangulation if topology changed
if (!mIsDelaunayUpToDate)
{
clearVector(mVertices);
for (std::vector<Block>::const_iterator it = mBlocks.begin(); it != mBlocks.end(); ++it)
{
mVertices.push_back(it->getPosition());
}
//Screen corners
mVertices.push_back(Vector2(GUI_WIDTH - 1.0f, -1.0f));
mVertices.push_back(Vector2(SCREEN_WIDTH, -1.0f));
mVertices.push_back(Vector2(SCREEN_WIDTH, SCREEN_HEIGHT));
mVertices.push_back(Vector2(GUI_WIDTH - 1.0f, SCREEN_HEIGHT));
clearVector(mTriangles);
triangulate(mVertices, mTriangles, mNeighborhoodGraph);
mIsDelaunayUpToDate = true;
}
//If no leader found, only Delaunay triangles drawn
if (mLeader != 0)
{
float xMin = GUI_WIDTH - 1.0f;
float xMax = SCREEN_WIDTH;
float yMin = -1.0f;
float yMax = SCREEN_HEIGHT;
const float screenBoundaries[] = { xMin, xMax, yMin, yMax };
clearVector(mPathVertices);
if (aStar(mPathVertices, mLeader->getPosition(), mPathFinish, mTriangles, mNeighborhoodGraph, mBlocks, screenBoundaries))
{
mGui.print("Path found to target.");
}
else
{
mGui.print("No accessible path to target.");
}
}
}
/*****************************************************************************
* Function Name: ReadyToAcquireData()
******************************************************************************
* Summary:
* Operations to indicate that we are ready to acquire the Capsense data.
*
* Parameters:
* None.
*
* Return:
* None.
*
* Note:
*
*****************************************************************************/
void ReadyToAcquireData(void)
{
// Set flags.
Status_Acquiring = FALSE;
Status_NoMoreSpace = FALSE;
Status_Sending = FALSE;
Status_NoMoreData = FALSE;
Status_Ready = TRUE;
// Clear previous data.
clearVector();
}
violet::HUD::~HUD() {
reset();
clearMap<PlayerBonusType, StaticObject*> (&m_bonusImg);
clearVector(&m_inventoryImg);
}
CVisualContainer::~CVisualContainer() {
clearVector();
}
void TrackDisplay::clearMap() {
std::map<int, std::vector<ogre_tools::BillboardLine*> >::iterator it;
for (it = lines.begin(); it != lines.end(); it++) {
clearVector(it->second);
}
}
void SymbolicMX::evaluateSX(const SXMatrixPtrV& input, SXMatrixPtrV& output, const SXMatrixPtrVV& fwdSeed, SXMatrixPtrVV& fwdSens, const SXMatrixPtrVV& adjSeed, SXMatrixPtrVV& adjSens){
clearVector(adjSeed);
}
HitBoxVector::~HitBoxVector()
{
clearVector();
}
AnimatedGif::~AnimatedGif()
{
clearVector(frames);
}
/*****************************************************************************
* Function Name: SendData()
******************************************************************************
* Summary:
* Operations to send the Capsense data.
*
* Parameters:
* None.
*
* Return:
* None.
*
* Note:
*
*****************************************************************************/
void SendData(void)
{
// Set flags.
Status_DataAcquired = FALSE;
Status_Sending = TRUE;
#if LOWPOWERMODE_ENABLED
// Delay between each send command.
if (numConnInterval == CONN_INTERVAL_DELAY) {
numConnInterval = 0u;
#else
// Delay so the Event stack doesn't get overloaded.
TimerDelay_Start();
if (_Timer_DelayDone) {
TimerDelay_Stop();
_Timer_DelayDone = FALSE;
#endif
// Send as many sets of values as possible (for all sensors).
if(NO_MORE_DATA == _BLE_sendCapSenseData())
Status_NoMoreData = TRUE;
else
Status_NoMoreData = FALSE;
}
#if LOWPOWERMODE_ENABLED
else
numConnInterval++;
#endif
}
/*****************************************************************************
* Function Name: ResetSystem()
******************************************************************************
* Summary:
* Reset everything here.
*
* Parameters:
* None.
*
* Return:
* None.
*
* Note:
*
*****************************************************************************/
void ResetSystem(void)
{
// Clear previous data.
clearVector();
// Reset status flags.
Status_Ready = TRUE;
Status_Acquiring = FALSE;
Status_NoMoreSpace = FALSE;
Status_DataAcquired = FALSE;
Status_Sending = FALSE;
Status_NoMoreData = FALSE;
// Reset the BLE module.
_BLE_Reset();
}
WhatsappChat::~WhatsappChat()
{
clearVector(messages);
}
void BuildMessagesThread::run()
{
if (!lock.tryLockWhile(running))
{
return;
}
clearVector(messages);
if (chat != NULL)
{
std::vector<WhatsappMessage *> &messages = chat->getMessages(running);
for (std::vector<WhatsappMessage *>::iterator it = messages.begin(); it != messages.end(); ++it)
{
if (!running)
{
break;
}
WhatsappMessage &message = **it;
ChatControlMessageFrame *messageFrame = NULL;
int color;
if (message.isFromMe())
{
color = RGB(190, 240, 150);
}
else
{
color = RGB(230, 230, 240);
}
switch (message.getMediaWhatsappType())
{
case MEDIA_WHATSAPP_TEXT:
{
messageFrame = new ChatControlMessageFrame(new ChatControlMessageText(message, 0, smileys), 0, color, dateFont);
} break;
case MEDIA_WHATSAPP_IMAGE:
{
if (message.getRawDataSize() > 0 && message.getRawData() != NULL)
{
messageFrame = new ChatControlMessageFrame(new ChatControlMessageImage(message, 0, imageDecoder), 0, color, dateFont);
}
} break;
case MEDIA_WHATSAPP_VIDEO:
{
if (message.getRawDataSize() > 0 && message.getRawData() != NULL)
{
messageFrame = new ChatControlMessageFrame(new ChatControlMessageVideo(message, 0, imageDecoder), 0, color, dateFont);
}
} break;
case MEDIA_WHATSAPP_LOCATION:
{
messageFrame = new ChatControlMessageFrame(new ChatControlMessageLocation(message, 0, imageDecoder), 0, color, dateFont);
} break;
}
if (messageFrame != NULL)
{
this->messages.push_back(messageFrame);
}
}
}
if (running)
{
PostMessage(window, WM_CHATCONTROL, CHAT_CONTROL_BUILDING_MESSAGES_FINISHED, 0);
}
lock.unlock();
}
ChatControlMessageText::~ChatControlMessageText()
{
clearVector(elements);
}
void BareMesh<GeoShapeType>::clear()
{
clearVector ( points );
clearVector ( pointMarkers );
clearVector ( pointIDs );
clearVector ( ridges );
clearVector ( ridgeMarkers );
clearVector ( ridgeIDs );
clearVector ( facets );
clearVector ( facetMarkers );
clearVector ( facetIDs );
clearVector ( elements );
clearVector ( elementMarkers );
clearVector ( elementIDs );
}
