Exemplo n.º 1
0
IPCProperty*
IPCPropertyMap::getOrCreateIPCProperty(const std::string& name, IPCVariantTypeEnum type)
{
    ExternalSegmentType::segment_manager* manager = _properties.get_allocator().get_segment_manager();

    CharAllocator_ExternalSegment charAlloc(manager);
    String_ExternalSegment nameKey(charAlloc);
    nameKey.append(name.c_str());

    IPCPropertyMap::IPCVariantMap::iterator found = _properties.find(nameKey);
    if (found != _properties.end()) {
        if (found->second.getType() != type) {
            assert(false);
            throw std::invalid_argument("A property with the name " + name + " already exists but with a different type");
        }
        return &found->second;
    }


    ExternalSegmentTypeIPCVariantAllocator vecAlloc(manager);
    IPCProperty prop(type, vecAlloc);

    // We must create the pair before or else this does not compile.
    IPCPropertyMap::IPCVariantMapValueType valPair = std::make_pair(nameKey, prop);
    std::pair<IPCPropertyMap::IPCVariantMap::iterator,bool> ret = _properties.insert(valPair);
    assert(ret.second);
    return &ret.first->second;
} // getOrCreateIPCProperty
Exemplo n.º 2
0
static int QRM( Mat a, Vec dv )
{
    Vec     ev, ev1;
    double  w, t, s, x, y, c;
    double  *v1, *v2;
    int     dim, iter;
    int     i, j, k, h;

    dim = a.row;
    if( dim != a.clm || dim < 2 ) return(-1);
    if( dv.clm != dim ) return(-1);

    ev = vecAlloc( dim );
    if( ev.clm != dim ) return(-1);

    ev1.clm = dim-1;
    ev1.v = &(ev.v[1]);
    if( vecTridiagonalize( a, dv, ev1 ) < 0 ) {
        vecFree( ev );
        return(-1);
    }

    ev.v[0] = 0.0;
    for( h = dim-1; h > 0; h-- ) {
        j = h;
        while(fabs(ev.v[j]) > EPS*(fabs(dv.v[j-1])+fabs(dv.v[j]))) j--;
        if( j == h ) continue;

        iter = 0;
        do{
            iter++;
            if( iter > MAX_ITER ) break;

            w = (dv.v[h-1] - dv.v[h]) / 2;
            t = ev.v[h] * ev.v[h];
            s = sqrt(w*w+t); 
            if( w < 0 ) s = -s;
            x = dv.v[j] - dv.v[h] + t/(w+s);
            y = ev.v[j+1];
            for( k = j; k < h; k++ ) {
                if( fabs(x) >= fabs(y) ) {
		    if( fabs(x) > VZERO ) {
			t = -y / x;
			c = 1 / sqrt(t*t+1);
			s = t * c;
		    }
		    else{
			c = 1.0;
			s = 0.0;
		    }
                }
                else{
		    t = -x / y;
		    s = 1.0 / sqrt(t*t+1);
		    c = t * s;
                }
                w = dv.v[k] - dv.v[k+1];
                t = (w * s + 2 * c * ev.v[k+1]) * s;
                dv.v[k]   -= t;
                dv.v[k+1] += t;
                if( k > j) ev.v[k] = c * ev.v[k] - s * y;
                ev.v[k+1] += s * (c * w - 2 * s * ev.v[k+1]);

                for( i = 0; i < dim; i++ ) {
                    x = a.m[k*dim+i];
                    y = a.m[(k+1)*dim+i];
                    a.m[k*dim+i]     = c * x - s * y;
                    a.m[(k+1)*dim+i] = s * x + c * y;
                }
                if( k < h-1 ) {
                    x = ev.v[k+1];
                    y = -s * ev.v[k+2];
                    ev.v[k+2] *= c;
                }
            }
        } while(fabs(ev.v[h]) > EPS*(fabs(dv.v[h-1])+fabs(dv.v[h])));
    }

    for( k = 0; k < dim-1; k++ ) {
        h = k;
        t = dv.v[h];
        for( i = k+1; i < dim; i++ ) {
            if( dv.v[i] > t ) {
                h = i;
                t = dv.v[h];
            }
        }
        dv.v[h] = dv.v[k];
        dv.v[k] = t;
        v1 = &(a.m[h*dim]);
        v2 = &(a.m[k*dim]);
        for( i = 0; i < dim; i++ ) {
            w = *v1;
            *v1 = *v2;
            *v2 = w;
            v1++;
            v2++;
        }
    }

    vecFree( ev );
    return(0);
}