asd

class tetraedr {
protected:
    vector v1,v2,v3,v4;                                 //points tetraedr
public:
    tetraedr(void);                                     //default constructor
    tetraedr(const tetraedr&);                          //copy constructor
    tetraedr(vector,vector,vector,vector);              //constructor
    double Vol();                                       //volume tetraedr
    double Sbok();                                      //square side cover
    vector& operator[](int);                            //select point!
    friend const tetraedr& operator ++(tetraedr&);      //prefix inc
    friend const tetraedr operator ++(tetraedr&, int);  //postfix inc
    void operator =(const tetraedr&);
};
bool operator >(tetraedr,tetraedr);         //tetraedr > tetraedr
bool operator <=(tetraedr,tetraedr);   //inverse *up*
bool operator <(tetraedr,tetraedr);         //tetraedr < tetraedr
bool operator >=(tetraedr,tetraedr);   //inverse *up*
bool operator ==(tetraedr,tetraedr);   //tetraedr == tetraedr
bool operator !=(tetraedr,tetraedr);   //inverse *up*
tetraedr operator +(tetraedr,tetraedr);     //tetraedr + tetraedr
void print(tetraedr, const char[255]=" ");  //Print tetraedr.
tetraedr operator *(double,tetraedr);       //K*TETRAEDR

/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////

void tetraedr::operator =(const tetraedr& A) {
    v1=A.v1;
    v2=A.v2;
    v3=A.v3;
    v4=A.v4;
}


//SRAVNENIYA
bool operator >(tetraedr A, tetraedr B) {
    return (A.Vol()>B.Vol())
            ?   1
            :   0;
}
bool operator <=(tetraedr A, tetraedr B) {
    return B>A;
}
bool operator <(tetraedr A, tetraedr B) {
    return (A.Vol()<B.Vol())
            ?   1
            :   0;
}
bool operator >=(tetraedr A, tetraedr B) {
    return B<A;
}
bool operator ==(tetraedr A, tetraedr B) {
    return (fabs(A.Vol()-B.Vol()) < MALO)
            ?   1
            :   0;
}
bool operator !=(tetraedr A, tetraedr B) {
    return !(A==B);
}
//INCREMENT PREFIX
const tetraedr& operator ++(tetraedr& A) {
    A.v1=A.v1+1;
    A.v2=A.v2+1;
    A.v3=A.v3+1;
    A.v4=A.v4+1;
return A;
}
//INCREMENT POSTFIX
const tetraedr operator ++(tetraedr& A, int) {
    tetraedr Old(A);
    ++A;
    return Old;

}

vector& tetraedr::operator[](int a) {
    switch(a) {
    case 0: return v1;
    case 1: return v2;
    case 2: return v3;
    case 3: return v4;
    };
    return v4;
}


void print(tetraedr A, const char a[255]) {
    printf("\nTetraedr: %s\n",a);
    print(A[0]);
    print(A[1]);
    print(A[2]);
    print(A[3]);
}

tetraedr::tetraedr(void) {
    v1[0]=0;    v1[1]=0;    v1[2]=0;
    v2[0]=1;    v2[1]=0;    v2[2]=0;
    v3[0]=0;    v3[1]=1;    v3[2]=0;
    v4[0]=0;    v4[1]=0;    v4[2]=1;
}

tetraedr::tetraedr(const tetraedr& z) {
    v1=z.v1;
    v2=z.v2;
    v3=z.v3;
    v4=z.v4;
}

tetraedr::tetraedr(vector a,vector b, vector c, vector d) {
    v1=a;
    v2=b;
    v3=c;
    v4=d;
}

double tetraedr::Sbok(void) {
    return 0.5*v_prod3(v2-v1,v3-v1).abs()+0.5*v_prod3(v2-v1,v4-v1).abs()+0.5*v_prod3(v3-v1,v4-v1).abs()+0.5*v_prod3(v3-v2,v4-v2).abs();
}

double tetraedr::Vol(void) {
return 1.0/6*fabs(det3(v2-v1,v3-v1,v4-v1));
}

tetraedr operator+(tetraedr A, tetraedr B) {
    tetraedr C;
    C[0]=A[0]+B[0];
    C[1]=A[1]+B[1];
    C[2]=A[2]+B[2];
    C[3]=A[3]+B[3];
    return C;
}

tetraedr operator *(double k,tetraedr A) {
    tetraedr temp;
    temp[0]=A[0]*k;
    temp[1]=A[1]*k;
    temp[2]=A[2]*k;
    temp[3]=A[3]*k;
    return temp;
}