C++ Coordinates::push_back方法代码示例

void Clipping::clipBottom(Coordinates& input, Coordinates& output){
    if(output.size() > 0)
        output.clear();
    if(input.size() == 0)
        return;

    double clipY = m_w->minY;
    input.push_back(input[0]);
    for(unsigned int i = 0; i < input.size()-1; i++){
        Coordinate c0 = input[i];
        Coordinate c1 = input[i+1];

        //Caso 1: out -> out
        if(c0.y < clipY && c1.y < clipY){
            continue;
        }

        //Caso 2: in -> in
        if(c0.y >= clipY && c1.y >= clipY){
            output.push_back(c1);
            continue;
        }

        double y = clipY;
        double m = (c1.x-c0.x)/(c1.y-c0.y);
        double x = m * (y-c0.y) + c0.x;

        //Caso 3: in -> out
        if(c0.y >= clipY && c1.y < clipY){
            output.emplace_back(x,y);
            continue;
        }

        //Caso 4: out -> in
        if(c0.y < clipY && c1.y >= clipY){
            output.emplace_back(x,y);
            output.push_back(c1);
        }
    }
}

void Clipping::clipRight(Coordinates& input, Coordinates& output){
    if(output.size() > 0)
        output.clear();
    if(input.size() == 0)
        return;

    double clipX = m_w->maxX;
    input.push_back(input[0]);
    for(unsigned int i = 0; i < input.size()-1; i++){
        Coordinate c0 = input[i];
        Coordinate c1 = input[i+1];

        //Caso 1: out -> out
        if(c0.x > clipX && c1.x > clipX){
            continue;
        }

        //Caso 2: in -> in
        if(c0.x <= clipX && c1.x <= clipX){
            output.push_back(c1);
            continue;
        }

        double x = clipX;
        double m = (c1.y-c0.y)/(c1.x-c0.x);
        double y = m * (x-c0.x) + c0.y;

        //Caso 3: in -> out
        if(c0.x <= clipX && c1.x > clipX){
            output.emplace_back(x,y);
            continue;
        }

        //Caso 4: out -> in
        if(c0.x > clipX && c1.x <= clipX){
            output.emplace_back(x,y);
            output.push_back(c1);
        }
    }
}

void MessageHandleJob::handleChunkReplica()
{
    boost::shared_ptr<scidb_msg::Chunk> chunkRecord = _messageDesc->getRecord<scidb_msg::Chunk>();

    const int compMethod = chunkRecord->compression_method();
    const size_t decompressedSize = chunkRecord->decompressed_size();
    const AttributeID attributeID = chunkRecord->attribute_id();
    const size_t count = chunkRecord->count();

    assert(_query);
    RWLock::ErrorChecker noopEc;
    ScopedRWLockRead shared(_query->queryLock, noopEc);
    Coordinates coordinates;
    for (int i = 0; i < chunkRecord->coordinates_size(); i++) {
        coordinates.push_back(chunkRecord->coordinates(i));
    }

    shared_ptr<ArrayDesc> desc = SystemCatalog::getInstance()->getArrayDesc(chunkRecord->array_id());
    if(chunkRecord->tombstone())
    { // tombstone record
        StorageManager::getInstance().removeLocalChunkVersion(*desc, coordinates);
    }
    else if (decompressedSize == 0)
    { // clone of replica
        shared_ptr<ArrayDesc> sourceDesc = SystemCatalog::getInstance()->getArrayDesc(chunkRecord->source_array_id());
        StorageManager::getInstance().cloneChunk(coordinates, *desc, attributeID, *sourceDesc, chunkRecord->source_attribute_id());
    }
    else 
    { // regular chunk
        boost::shared_ptr<ArrayIterator> outputIter = StorageManager::getInstance().getArrayIterator(*desc, attributeID, _query);
        boost::shared_ptr<CompressedBuffer> compressedBuffer = dynamic_pointer_cast<CompressedBuffer>(_messageDesc->getBinary());
        compressedBuffer->setCompressionMethod(compMethod);
        compressedBuffer->setDecompressedSize(decompressedSize);
        Chunk& outChunk = outputIter->newChunk(coordinates, compMethod);
        outChunk.setSparse(chunkRecord->sparse());
        outChunk.setRLE(chunkRecord->rle());
        outChunk.decompress(*compressedBuffer); // TODO: it's better avoid decompression. It can be written compressed
        outChunk.setCount(count);
        outChunk.write(_query);
    }
    if (static_cast<MessageType>(_messageDesc->getMessageType()) != mtChunkReplica) {
       return;
    }
    assert(sourceId != INVALID_INSTANCE);
    if (_query->chunkReplicasReqs[sourceId].decrement()) {
        boost::shared_ptr<MessageDesc> resultMessage = boost::make_shared<MessageDesc>(mtReplicaSyncResponse);
        resultMessage->setQueryID(_query->getQueryID());
        networkManager.sendMessage(_messageDesc->getSourceInstanceID(), resultMessage);
    }
}

        Graph GeneratorRANDOM::Generate(int n, int m)
        {
            if(m > n*(n-1)/2)
                throw "cannot have more than n*(n-1)/2 edges";
            srand(time(NULL));

            Graph G(n);
            for(VertexIterator v = G.BeginVertices(); v != G.EndVertices(); v++)
            {
                Coordinates coords;
                coords.push_back( (rand() % 200) / 10.0f );
                coords.push_back( (rand() % 200) / 10.0f );
                (*v)->SetCoordinates(coords);
            }

            // initialize vector "allindices"
            vector<int> allindices(n*(n-1)/2);
            for(int i = (n*(n-1)/2)-1; i >= 0; i--)
                allindices[i] = i;

            // randomize vector "allindices"
            for(int i = (n*(n-1)/2)-1; i > 0; i--)
            {
                int rand_idx = rand() % (i+1);
                int temp = allindices[i];
                allindices[i] = allindices[rand_idx];
                allindices[rand_idx] = temp;
            }

            // select first m indices from randomized "allindices"
            set<int> selected_indices;
            for(int i = m-1; i >= 0; i--)
                selected_indices.insert(allindices[i]);

            // insert the edges with the selected indices into the graph
            int i = 0;
            for(VertexIterator v = G.BeginVertices(); v != G.EndVertices(); v++)
            {
                VertexIterator v1 = v;
                for(v1++; v1 != G.EndVertices(); v1++)
                {
                    if(selected_indices.find(i) != selected_indices.end())
                        G.AddEdge(v,v1);
                    i++;
                }
            }

            return G;
        }

void Coordinates_test::
t_readwrite()
{
    Coordinates c;
    c.clear();
    QCOMPARE(c.count(), 0);
    c << 1.0 << 3.0;
    c.clear();
    QCOMPARE(c.count(), 0);
    c << 1.0 << 3.0;
    c.erase(c.begin(), c.end());
    QCOMPARE(c.count(), 0);
    c << 1.0 << 0.0;
    Coordinates::iterator i= c.erase(c.begin());
    QCOMPARE(*i, 0.0);
    i= c.insert(c.end(), 1.0);
    QCOMPARE(*i, 1.0);
    QCOMPARE(c.count(), 2);
    c.pop_back();
    QCOMPARE(c.count(), 1);   // 0
    QCOMPARE(c[0], 0.0);
    c.push_back(2.0);
    QCOMPARE(c.count(), 2);
    c.append(3.0);
    QCOMPARE(c.count(), 3);   // 0, 2, 3
    QCOMPARE(c[2], 3.0);
    c.insert(0, 4.0);
    QCOMPARE(c[0], 4.0);
    QCOMPARE(c[3], 3.0);
    c.insert(c.count(), 5.0);
    QCOMPARE(c.count(), 5);   // 4, 0, 2, 3, 5
    QCOMPARE(c[4], 5.0);
    c.move(4, 0);
    QCOMPARE(c.count(), 5);   // 5, 4, 0, 2, 3
    QCOMPARE(c[0], 5.0);
    c.pop_front();
    QCOMPARE(c.count(), 4);
    QCOMPARE(c[0], 4.0);
    c.prepend(6.0);
    QCOMPARE(c.count(), 5);   // 6, 4, 0, 2, 3
    QCOMPARE(c[0], 6.0);
    c.push_front(7.0);
    QCOMPARE(c.count(), 6);
    QCOMPARE(c[0], 7.0);
    c.removeAt(1);
    QCOMPARE(c.count(), 5);   // 7, 4, 0, 2, 3
    QCOMPARE(c[1], 4.0);
    c.removeFirst();
    QCOMPARE(c.count(), 4);   // 4, 0, 2, 3
    QCOMPARE(c[0], 4.0);
    c.removeLast();
    QCOMPARE(c.count(), 3);
    QCOMPARE(c.last(), 2.0);
    c.replace(2, 8.0);
    QCOMPARE(c.count(), 3);   // 4, 0, 8
    QCOMPARE(c[2], 8.0);
    c.swap(0, 2);
    QCOMPARE(c[2], 4.0);
    double d= c.takeAt(2);
    QCOMPARE(c.count(), 2);   // 8, 0
    QCOMPARE(d, 4.0);
    double d2= c.takeFirst();
    QCOMPARE(c.count(), 1);   // 0
    QCOMPARE(d2, 8.0);
    double d3= c.takeLast();
    QVERIFY(c.isEmpty()); \
    QCOMPARE(d3, 0.0);
}//t_readwrite

void Viewport::transformCoordinates(const Coordinates& coords, Coordinates& output) const {
    for(const auto &c : coords)
        output.push_back(transformCoordinate(c));
}

void MessageHandleJob::_handleChunkOrAggregateChunk(bool isAggregateChunk)
{
    boost::shared_ptr<scidb_msg::Chunk> chunkRecord = _messageDesc->getRecord<scidb_msg::Chunk>();
    assert(!chunkRecord->eof());
    assert(_query);
    RWLock::ErrorChecker noopEc;
    ScopedRWLockRead shared(_query->queryLock, noopEc);

    try
    {
        if (! isAggregateChunk) {
            // TODO: Apply it to statistics of current SG
            currentStatistics->receivedSize += _messageDesc->getMessageSize();
            currentStatistics->receivedMessages++;
        }

        LOG4CXX_TRACE(logger, "Next chunk message was received")
        const int compMethod = chunkRecord->compression_method();
        const size_t decompressedSize = chunkRecord->decompressed_size();
        const AttributeID attributeID = chunkRecord->attribute_id();
        const size_t count = chunkRecord->count();

        boost::shared_ptr<SGContext> sgCtx = dynamic_pointer_cast<SGContext>(_query->getOperatorContext());
        if (sgCtx == NULL) {
            throw (SYSTEM_EXCEPTION(SCIDB_SE_INTERNAL, SCIDB_LE_UNKNOWN_CTX)
                   << typeid(*_query->getOperatorContext()).name());
        }

        boost::shared_ptr<Array> outputArray = sgCtx->_resultSG;
        ScopedMutexLock cs(_query->resultCS);
        boost::shared_ptr<ArrayIterator> outputIter = outputArray->getIterator(attributeID);

        const bool shouldCacheEmptyBitmap = sgCtx->_shouldCacheEmptyBitmap;
        const ArrayDesc& desc = outputArray->getArrayDesc();
        const size_t sourceId = _query->mapPhysicalToLogical(_messageDesc->getSourceInstanceID());
        const bool isEmptyable = (desc.getEmptyBitmapAttribute() != NULL);
        const bool isEmptyIndicator = isEmptyable && (attributeID+1==desc.getAttributes().size());
        const bool rle = chunkRecord->rle();

        if (isAggregateChunk) {
            assert(! isEmptyIndicator);
        }

        Coordinates coordinates;
        for (int i = 0; i < chunkRecord->coordinates_size(); i++) {
            coordinates.push_back(chunkRecord->coordinates(i));
        }

        if (!isAggregateChunk && sgCtx->_targetVersioned)
        {
            sgCtx->_newChunks.insert(coordinates);
        }

        boost::shared_ptr<CompressedBuffer> compressedBuffer = dynamic_pointer_cast<CompressedBuffer>(_messageDesc->getBinary());
        if (compressedBuffer) {
            assert(compressedBuffer->getData());
            PinBuffer pin(*compressedBuffer); // this line protects compressedBuffer->data from being freed, allowing MemChunk::decompressed(*compressedBuffer) to be called multiple times.

            compressedBuffer->setCompressionMethod(compMethod);
            compressedBuffer->setDecompressedSize(decompressedSize);
            Chunk* outChunk;

            // temporary MemArray objects
            shared_ptr<MemChunk> pTmpChunk = make_shared<MemChunk>();  // make it a shared pointer, because the bitmap chunk needs to be preserved across threads.
            MemChunk closure;

            // the PinBuffer objects protect tmpChunk and closure, respectively.
            shared_ptr<PinBuffer> pinTmpChunk, pinClosure;

            if (outputIter->setPosition(coordinates)) { // existing chunk
                outChunk = &outputIter->updateChunk();

                if (! isAggregateChunk) {
                    if (outChunk->getDiskChunk() != NULL) {
                        throw SYSTEM_EXCEPTION(SCIDB_SE_MERGE, SCIDB_LE_CANT_UPDATE_CHUNK);
                    }
                    outChunk->setCount(0); // unknown
                }

                // if (a) either dest is NULL or merge by bitwise-or is possible; and (b) src is not compressed
                char* dst = static_cast<char*>(outChunk->getData());
                if ( (dst == NULL || (outChunk->isPossibleToMergeByBitwiseOr() && !chunkRecord->sparse() && !chunkRecord->rle()))
                     &&
                     compMethod == 0 )
                {
                    char const* src = (char const*)compressedBuffer->getData();

                    // Special care is needed if shouldCacheEmptyBitmap.
                    // - If this is the empty bitmap, store it in the SGContext.
                    // - Otherwise, add the empty bitmap from the SGContext to the chunk's data.
                    if (shouldCacheEmptyBitmap) {
                        initMemChunkFromNetwork(pTmpChunk, pinTmpChunk, outputArray, coordinates, attributeID,
                                compMethod, chunkRecord->sparse() || outChunk->isSparse(), rle, compressedBuffer);

                        if (isEmptyIndicator) {
                            sgCtx->setCachedEmptyBitmapChunk(sourceId, pTmpChunk, coordinates);
                        } else {
                            shared_ptr<ConstRLEEmptyBitmap> cachedBitmap = sgCtx->getCachedEmptyBitmap(sourceId, coordinates);
                            assert(cachedBitmap);
                            pinClosure = make_shared<PinBuffer>(closure);
//.........这里部分代码省略.........

        void TransformerSPRINGEMBEDDER::SpringEmbed(Graph& G, vector<float> dimension_limits, IntermediateStepHandler* intermediatestephandler)
        {
            vector<VectorND> tractions;
            int dimensions = dimension_limits.size();

            unstressed_spring_length = dimension_limits[0];
            for(int i = 1; i < dimensions; i++)
                unstressed_spring_length *= dimension_limits[i];
            unstressed_spring_length /= G.NumberOfVertices();
            unstressed_spring_length = pow(unstressed_spring_length, 1.0f/dimensions) / (dimensions * 2);

            // init
            srand ( time(NULL) );
            for(VertexIterator a = G.BeginVertices(); a != G.EndVertices(); a++)
            {
                Coordinates coordinates;
                for(int i = 0; i < dimensions; i++)
                    coordinates.push_back(fmod(rand(), dimension_limits[i]));
                (*a)->SetCoordinates(coordinates);

                // should make sure that no two vertices have the same position
                tractions.push_back(VectorND(dimensions));
            }

            float max_movement;
            iteration = 0;
            do
            {
                // compute movement
                max_movement = 0;
                int i = 0;
                for(VertexIterator a = G.BeginVertices(); a != G.EndVertices(); a++, i++)
                {

                    VectorND traction = tractions[i] * friction;

                    // compute forces on a by the other vertices
                    VectorND aCoordinates((*a)->GetCoordinates(0));
                    for(VertexIterator b = G.BeginVertices(); b != G.EndVertices(); b++)
                    {
                        if(b==a)
                            continue;

                        // force on a by vertex b
                        VectorND bCoordinates((*b)->GetCoordinates(0));
                        traction += coulomb(aCoordinates, bCoordinates);
                        if((*a)->Adjacent(*b))
                            traction += hooke(aCoordinates, bCoordinates);
                    }

                    tractions[i] = traction;
                }


                // execute movement
                VertexIterator a = G.BeginVertices();
                for(int i = 0; a != G.EndVertices(); a++, i++)
                {
                    Coordinates OldCoordinates = (*a)->GetCoordinates(0);
                    Coordinates NewCoordinates(dimensions);
                    for(int j = 0; j < dimensions; j++)
                        NewCoordinates[j] = max(0.0f,min(dimension_limits[j],   OldCoordinates[j] + delta * tractions[i][j]   ));
                    (*a)->SetCoordinates( NewCoordinates );

                    // for the loop-condition
                    float current_movement = 0.0f;
                    for(int j = 0; j < dimensions; j++)
                        current_movement += (OldCoordinates[j] - NewCoordinates[j]) * (OldCoordinates[j] - NewCoordinates[j]);
                    if(sqrt(current_movement) > max_movement)
                        max_movement = sqrt(current_movement);
                }


                if(intermediatestephandler != NULL)
                    intermediatestephandler->Handle(&G);

                if(++iteration > nextincrease)
                {
                    movement_threshold += 0.01f;
                    nextincrease *= 4;
                }
                if(iteration > max_iterations)
                    break;

            }
            while(max_movement > movement_threshold*unstressed_spring_length);

        }

    ConstChunk const& MatchArrayIterator::getChunk()
    {
        Coordinates const& currPos = inputIterator->getPosition();
        if (chunk.isInitialized() && currPos == chunk.getFirstPosition(false)) {
           return chunk;
        }
        ConstChunk const& srcChunk = inputIterator->getChunk();
        MatchArray& array = (MatchArray&)this->array;
        match = array.findMatch(currPos);
        Coordinates chunkPos = currPos;
        chunkPos.push_back(0);
        Address addr(attr, chunkPos);
        chunk.initialize(&array, &array.getArrayDesc(), addr, 0);

        std::shared_ptr<Query> emptyQuery;
        std::shared_ptr<ChunkIterator> dst = chunk.getIterator(emptyQuery, ChunkIterator::SEQUENTIAL_WRITE|ChunkIterator::NO_EMPTY_CHECK);

        if (match->initialized) {
            std::shared_ptr<ConstChunkIterator> src = srcChunk.getConstIterator(ConstChunkIterator::IGNORE_EMPTY_CELLS);
            int64_t itemNo = 0;
            if (attr < array.nPatternAttributes) {
                for (; !src->end(); ++(*src), ++itemNo) {
                    MatchHash::Elem* elem = match->find(itemNo);
                    if (elem != NULL) {
                        Coordinates elemPos(src->getPosition());
                        elemPos.push_back(0);
                        do {
                            if (elem->hash == itemNo) {
                                if (!dst->setPosition(elemPos)) {
                                    throw USER_EXCEPTION(SCIDB_SE_EXECUTION, SCIDB_LE_NO_CURRENT_POSITION);
                                }
                                dst->writeItem(src->getItem());
                                elemPos.back() += 1;
                            }
                            elem = elem->collisionChain;
                        } while (elem != NULL);
                    }
                }
            } else if (attr < array.nPatternAttributes + array.nCatalogAttributes) {
                if (catalogIterator->setPosition(currPos)) {
                    std::shared_ptr<ConstChunkIterator> ci = catalogIterator->getChunk().getConstIterator(ConstChunkIterator::IGNORE_EMPTY_CELLS);
                    for (; !src->end(); ++(*src), ++itemNo) {
                        MatchHash::Elem* elem = match->find(itemNo);
                        if (elem != NULL) {
                            Coordinates elemPos(src->getPosition());
                            elemPos.push_back(0);
                            do {
                                if (elem->hash == itemNo) {
                                    if (!dst->setPosition(elemPos)) {
                                        throw USER_EXCEPTION(SCIDB_SE_EXECUTION, SCIDB_LE_NO_CURRENT_POSITION);
                                    }
                                    if (!ci->setPosition(elem->coords)) {
                                        throw USER_EXCEPTION(SCIDB_SE_EXECUTION, SCIDB_LE_NO_CURRENT_POSITION);
                                    }
                                    dst->writeItem(ci->getItem());
                                    elemPos.back() += 1;
                                }
                                elem = elem->collisionChain;
                            } while (elem != NULL);
                        }
                    }
                }
            } else if (attr < array.nPatternAttributes + array.nCatalogAttributes + currPos.size()) {
                size_t dimNo = attr - array.nPatternAttributes - array.nCatalogAttributes;
                Value coordValue;
                for (; !src->end(); ++(*src), ++itemNo) {
                    MatchHash::Elem* elem = match->find(itemNo);
                    if (elem != NULL) {
                        Coordinates elemPos(src->getPosition());
                        elemPos.push_back(0);
                        do {
                            if (elem->hash == itemNo) {
                                if (!dst->setPosition(elemPos)) {
                                    throw USER_EXCEPTION(SCIDB_SE_EXECUTION, SCIDB_LE_NO_CURRENT_POSITION);
                                }
                                coordValue.setInt64(elem->coords[dimNo]);
                                dst->writeItem(coordValue);
                                elemPos.back() += 1;
                            }
                            elem = elem->collisionChain;
                        } while (elem != NULL);
                    }
                }
            } else {
                Value trueValue;
                trueValue.setBool(true);
                for (; !src->end(); ++(*src), ++itemNo) {
                    MatchHash::Elem* elem = match->find(itemNo);
                    if (elem != NULL) {
                        Coordinates elemPos(src->getPosition());
                        elemPos.push_back(0);
                        do {
                            if (elem->hash == itemNo) {
                                if (!dst->setPosition(elemPos)) {
                                    throw USER_EXCEPTION(SCIDB_SE_EXECUTION, SCIDB_LE_NO_CURRENT_POSITION);
                                }
                                dst->writeItem(trueValue);
                                elemPos.back() += 1;
                            }
                            elem = elem->collisionChain;
//.........这里部分代码省略.........

Coordinates Viewport::transformCoordinates(const Coordinates& coords) const{
    Coordinates vCoords;
    for(const auto &c : coords)
        vCoords.push_back(transformCoordinate(c));
    return vCoords;
}