dvector.cc

c到DHL的转换工具

//=                printf("ex makes it independent \n");
                set_indep();
            } else {
//= vvv
/*                printf("Gcd gave ");
                dv->print(stdout); printf("\n");
                printf("The set of direction vectors is\n");
                ex->directions()->print(stdout);
                printf("\n");
                */
//= ^^^
                
                dir_list *dl = ex->directions();
                if (!indep()) dl->add_unused(loop_used+num_symb,
                                             2*minnest);
                if (flow) {
                    dl->flow_reduce(loop_used+num_symb);
                } 
                while(dl) {
                    distance_vector *dv2 = 
                        new distance_vector();
                    dir_array *da = dl->data;
                    dl = dl->next;
                    distance_vector_iter iter1(dv);
                    for (int s=0; s<da->size; s++) {
                        distance dis;
                        if (loop_used[num_symb+2*s]) {
                            assert(!iter1.is_empty());
                            dis = iter1.step()->d;
                            if (!dis.is_const()) {
                                dis = da->data[s];
                            }
                        } else {
                            dis=da->data[s];
                        }
                        dv2->append(dis);
                    }
                    push(new dvlist_e(dv2));
                }
                delete dl;
            }
            delete ex;
        } else {
            dv->add_unused(loop_used+num_symb, 2*minnest);
            push(new dvlist_e(dv));
        }
    } else {
        set_indep();
    }
    delete a1i; delete a2i; delete newa1; delete newa2;
    delete loop_used; delete L; delete U; 
    delete symbols; 
//=    printf("The result is2 \n"); this->print(stdout); printf("\n");
}


// collapse a list of direction vectors into 1
// by oring in the directions
void dvlist::collapse(distance_vector *output)
{
    if (this->indep()) output->set_indep();
    else {
        output->set_dep();
        int first_time=1;
        dvlist_iter iterator(this);
        for (; !iterator.is_empty();) {
            distance_vector *dv = iterator.step()->dv;	
            if (first_time) {
                first_time = 0;
                distance_vector_iter iter1(dv);
                while(!iter1.is_empty()) {
                    output->append(iter1.step()->d);
                }
            } else {
                distance_vector_iter iter1(output);
                distance_vector_iter iter2(dv);
                while(!iter1.is_empty()) {
                    assert(!iter2.is_empty());
                    distance *d1 = &iter1.step()->d;
                    distance *d2 = &iter2.step()->d;
                    if (d1->is_const() && d2->is_const()) {
                        assert(d1->dist()==d2->dist());
                    } else {
                        direction newd = direction(d1->dir()|d2->dir());
                        d1->set_direction(newd);
                    }
                }
            }
        }
    }
}




//
// initialize a distance vector to the same as another
//
distance_vector::distance_vector(distance_vector * dv)
{
    if (dv -> indep()) {
        set_indep();
    } else {
        set_dep();
        distance_vector_iter iterator(dv);
        for(; !iterator.is_empty();) {
            append(iterator.step()->d);
        }
    }
}


//
// print a distance vector 
//
void distance_vector::print(FILE *str)
{
    if (indep()) {
        fprintf(str,"These vectors are independent \n");
    } else {
        fprintf(str,"( ");
        distance_vector_iter iterator(this);
        for(; !iterator.is_empty();) {
            iterator.step()->d.print(str);
        }
        fprintf(str,")\n");
    }
}


// 
// print a dvlist
//
void dvlist::print(FILE *str)
{
    if (indep()) {
        fprintf(str,"These vectors are independent \n");
    } else {
        dvlist_iter iterator(this);
        for(; !iterator.is_empty();) {
            iterator.step()->dv->print(str);
        }
    }
}


// print a distance
void distance::print(FILE *str)
{
    if (is_const()) {
        fprintf(str,"%d ",dist());
        if(dist() > 0) assert(dir() == d_lt);
        else if(dist() == 0) assert(dir() == d_eq);
        else assert(dir() == d_gt);
    } else {
        direction d=dir();
        switch(d) {
        case d_lt: fprintf(str,"+ "); break;   // lt
        case d_gt: fprintf(str,"- "); break;   // gt
        case d_eq: assert(0);
        case d_le: fprintf(str,"+/0 "); break;   // le
        case d_ge: fprintf(str,"0/- "); break;   // ge
        case d_lg: fprintf(str,"+/- "); break;   // lg
        case d_star: fprintf(str,"* "); break;
        }
    }
}


//
// is distance vector 0
//
int distance_vector::is_zero()
{
    if (indep()) {
        return TRUE;
    } else {
        distance_vector_iter iterator(this);
        for(; !iterator.is_empty();) {
            if (!(iterator.step() -> is_zero())) {
                return FALSE;
            }
        }
        return TRUE;
    }
}

/* turn leading >= into = */
void distance_vector::make_pos()
{
    distance d;
    distance_vector_e *dve;
    if (indep()) {
        return;
    } else {
        distance_vector_iter iterator(this);
        for(; !iterator.is_empty();) {
            dve = iterator.step();
            d = dve -> d;
            if (d.dir() == d_lt) {
                return;
            }
            if (d.dir() == d_gt) {
                return;
            }
            if (d.dir() == d_ge) {
                dve -> d.set_direction(d_eq);
            }
            if (d.dir() == d_lg) {
                return;
            }
            if (d.dir() == d_star) {
                return;
            }
            if (d.dir() == d_le) {
                return;
            }
            /* (d.dir() == d_eq) */
        }
        return;
    }
}

//
// is distance vector positive
//
int distance_vector::is_pos()
{
    distance d;
    
    if (indep()) {
        return FALSE;
    } else {
        distance_vector_iter iterator(this);
        for(; !iterator.is_empty();) {
            d = iterator.step() -> d;
            if (d.dir() == d_lt) {
                return TRUE;
            }
            if (d.dir() == d_gt) {
                return FALSE;
            }
            if (d.dir() == d_ge) {
                return FALSE;
            }
            if (d.dir() == d_lg) {
                return FALSE;
            }
            if (d.dir() == d_star) {
                return FALSE;
            }
            if ((d.dir() == d_le) || (d.dir() == d_eq));
        }
        return FALSE;
    }
}

//
// is distance vector negative
//
int distance_vector::is_neg()
{
    distance d;
    
    if (indep()) {
        return FALSE;
    } else {
        distance_vector_iter iterator(this);
        for(; !iterator.is_empty();) {
            d = iterator.step() -> d;
            if (d.dir() == d_gt)
                return TRUE;
            if (d.dir() == d_lt)
                return FALSE;
            if (d.dir() == d_le)
                return FALSE;
            if (d.dir() == d_lg)
                return FALSE;
            if (d.dir() == d_star)
                return FALSE;
            if ((d.dir() == d_ge) || (d.dir() == d_eq));
        }
        return FALSE;
    }
}

//
// is distance vector a star
//
int distance_vector::is_star()
{
    distance d;
    
    if (indep()) {
        return FALSE;
    } else {
        distance_vector_iter iterator(this);
        for(; !iterator.is_empty();) {
            d = iterator.step() -> d;
            if (d.is_star())
                return TRUE;
            if (d.dir() == d_eq);
            else return FALSE;
        }
        return FALSE;
    }
}


//
// return level of dependence
//
int distance_vector::level()
{
    distance d;
    int i;
    
    if (indep()) {
        return FALSE;
    } else {
        distance_vector_iter iterator(this);
        for(i = 1; !iterator.is_empty(); i++) {
            d = iterator.step() -> d;
            if (!d.is_zero() && !d.is_star())
                return i;
        }
        return i-1;
    }
}



//
// return number of elements in graph
//
int distance_vector::size()
{
    int i;
    
    if (indep()) {
        return 0;
    } else {
        distance_vector_iter iterator(this);
        for(i = 0; !iterator.is_empty(); i++) {
            iterator.step();
        }
        return i;
    }
}


//
// return level of dependence
//
distance *distance_vector::thresh(int level)
{
    distance d;
    int i;
    
    assert(!indep());
    distance_vector_iter iterator(this);
    for(i = 1; !iterator.is_empty(); i++) {
        d = iterator.step() -> d;
        if (i == level) {
            return new distance(&d);
        }
    }
    return(new distance(0));
    
}

//
// return level of first non-= or * dependence
// return 0 if all ='s or *'s
//
int distance_vector::first_not_eq()
{
    distance d;
    int i;
    
    assert(!indep());
    distance_vector_iter iterator(this);
    for(i = 1; !iterator.is_empty(); i++) {
        d = iterator.step() -> d;
        if (d.is_star())
            continue;
        if (!d.is_zero())
            return i;
    }
    return(0);
    
}


//
// return entry for level
//
distance distance_vector::entry(int level)
{
    int i;
    
    assert(!indep());
    distance_vector_iter iterator(this);
    for(i = 1; !iterator.is_empty(); i++) {
        distance_vector_e *e = iterator.step();
        if (i == level) {
            return e->d;
        }
    }
    assert(0);
    return(* new distance());
}

void distance_vector::set_entry(distance dd,int level)
{
    int i;
    
    assert(!indep());
    distance_vector_iter iterator(this);
    for(i = 1; !iterator.is_empty(); i++) {
        distance_vector_e *e = iterator.step();
        if (i == level) {
            e->d = dd;
            return;
        }
    }
    assert(0);
}

// 
// negate a distance
//
void distance::negate()
{
    if (is_const()) {
        int d = dist();
        set_distance(-d);
    } else {
        direction di=dir();
        switch (di) {
        case d_lt: set_direction(d_gt); break;
        case d_gt: set_direction(d_lt); break;
        case d_le: set_direction(d_ge); break;
        case d_ge: set_direction(d_le); break;
        default: break;
        }
    }
}

//
// negate all the distances
//
void distance_vector::negate()
{
    distance * d;
    
    if (indep()) {
        return;
    } else {
        distance_vector_iter iterator(this);
        for(; !iterator.is_empty();) {
            d = &(iterator.step() -> d);
            d->negate();