dalgo.cpp

数字电路故障分析之D算法C++实现。按照教科书编写

    bool done, matched;
    for(j = 0; j < nodeNum; j++)
    {
        res[j] = tc[j];
    }
    do
    {
        done = true;
        devPt = -1;
        for(i = 0; i < originalNum;)
        {
            if(devPt != originalDevMap[i])
            // For "devPt" = -1 initially, the block below must be executed
            // so "OutpNode" and "MatchStat" are assigned at first and the
            // warning can be ignored
            {
                devPt = originalDevMap[i];
                matchStat = 0;
                outpNode = devInfoList[devPt].outpNode;
            }
            if(originalTable[i][outpNode] == res[outpNode])
            {
                if(devPt == devNum - 1)
                {
                    lastCubeIndex = originalNum - 1;
                }
                else
                {
                    lastCubeIndex =
                            devInfoList[devPt + 1].firstOriginalCubeIndex - 1;
                }
                if(i > lastCubeIndex)
                {
                    return false;
                }
                for(; i <= lastCubeIndex; i++)
                // Probably it is not well-ordered by the output
                {
                    if(originalTable[i][outpNode] == res[outpNode])
                    {
                        matched = true;
                        for(j = 0; j < outpNode; j++)
                        // OriginalTable[i, j] contained in tc
                        {
                            if(originalTable[i][j] != DL_X)
                            {
                                // if(res[j] != originalTable[i][j]) &&
                                // res[j] != DL_X && res[j] != DL_D &&
                                // res[j] != DL_N)
                                if(res[j] != originalTable[i][j] &&
                                        res[j]!= DL_X)
                                {
                                    matched = false;
                                    break;
                                }
                            }
                        }
                        if (matched)
                        {
                            matchStat++;
                            if(matchStat > 1)
                            {
                                i++;
                                break;
                            }
                            lock = i;
                        }
                    }
                }   // for(; i < lastCubeIndex; i++)
                if(matchStat == 1)
                // "lock" must be assigned, ignore the warning
                {
                    for(j = 0; j < outpNode; j++)   // some j is confirmed
                    {
                        if(res[j] == DL_X)
                        {
                            res[j] = originalTable[lock][j];
                            if(res[j] != DL_X)
                            {
                                done = false;
                            }
                        }
                    }
                    i = lastCubeIndex + 1;
                }
                else if(matchStat == 0)
                {
                    return false;
                }
            }   // if(originalTable[i][outpNode] == res[outpNode])
            else
            {
                matched = true;
                for(j = 0; j < outpNode; j++)
                {
                    if(originalTable[i][j] != DL_X)
                    {
                        if(res[j] != originalTable[i][j])
                        {
                            matched = false;
                            break;
                        }
                    }
                }
                if(matched)
                {
                    if(res[outpNode] == DL_X)
                    {
                        res[outpNode] = originalTable[i][outpNode];
                        done = false;
                    }
                    else if(res[outpNode] != originalTable[i][outpNode] &&
                            res[outpNode] != DL_D && res[outpNode] != DL_N)
                    {
                        return false;
                    }
                    if(devPt == devNum - 1)
                    {
                        i = originalNum - 1;
                    }
                    else
                    {
                        i = devInfoList[devPt + 1].firstOriginalCubeIndex - 1;
                    }
                }
                i++;
            }
        }
    }while(!done);
    return true;
}

void DAlgorithmRenderer::setTCLen(int index, _Spec &spec) const
{
    int k, j;
    if(index >= spec.tailOfTC)
    {
        k = spec.tailOfTC;
        spec.tailOfTC += ExtStep;
        spec.tc.setRowNum(spec.tailOfTC);
        spec.aTable.setLength(spec.tailOfTC);
        for(; k < spec.tailOfTC; k++)
        {
            spec.tc.createRow(k, nodeNum);
            spec.aTable[k].devTable.setLength(devNum);
            for(j = 0; j < nodeNum; j++)
            {
                spec.tc[k][j] = DL_X;
            }
            for(j = 0; j < devNum; j++)
            {
                spec.aTable[k].devTable[j] = false;
            }
        }
    }
    else if(index < spec.tailOfTC - ExtStep)
    {
        k = spec.tailOfTC - 1;
        spec.tailOfTC -= ExtStep;
        spec.tc.setRowNum(spec.tailOfTC);
        spec.aTable.setLength(spec.tailOfTC);
    }
    spec.i = index;
}

TestNodeRes DAlgorithmRenderer::testNode(const _Spec &spec) const
{
    for(int j = 0; j < nodeNum; j++)
    {
        if(nodeStyleList[j] == Output && (spec.tc[spec.i][j] == DL_D ||
                spec.tc[spec.i][j] == DL_N))
        {
            return Out;
        }
        else if(spec.tc[spec.i][j] == DL_E)
        {
            return Fail;
        }
    }
    return NoOut;
}

void DAlgorithmRenderer::initializeAlg(_Spec &spec) const
{
    int inputIndex;
    DLogic nodeD;
    spec.c = faultDTable[spec.faultDIndex]; // reference of selected fault-D,
                                            // not a copy
    spec.i = 1;
    spec.tailOfTC = 0;
    setTCLen(spec.i, spec);
    if(spec.faultDIndex > inputNum)
    {
        spec.aTable[spec.i].curDev =
                originalDevMap[spec.faultDIndex - inputNum];
    }
    else
    {
        spec.aTable[spec.i].curDev = -1;
    }
    for(int j = 0; j < devNum; j++)
    {
        spec.aTable[spec.i].devTable[j] = false;
    }
}

void DAlgorithmRenderer::getNewA(_Spec &spec) const
//  A[i]=(A[i-1]-E)+(Devices adjacent to E)
{
    int curDevOutp;
    if(spec.aTable[spec.i - 1].curDev == -1)
    {
        curDevOutp = spec.faultDIndex / 2;
    }
    else
    {
        curDevOutp = devInfoList[spec.aTable[spec.i - 1].curDev].outpNode;
    }
    for(int k = 0; k < devNum; k++)
    {
        if(devInfoList[k].devCube[curDevOutp] == Input)
        {
            spec.aTable[spec.i].devTable[k] = true;   // select
        }
        else
        {
            spec.aTable[spec.i].devTable[k] =
                    spec.aTable[spec.i - 1].devTable[k];
        }
    }
    //  aTable[i].DevTable[aTable[i-1].CurDev] ==
    //  aTable[i-1].DevTable[aTable[i-1].CurDev]
    //  is aready deselected
    spec.aTable[spec.i].curDev = -1;
}

bool DAlgorithmRenderer::selectNewDev(_Spec &spec) const
//  return "false" if no dev exists
{
    for(int j = spec.aTable[spec.i].curDev + 1; j < devNum; j++)
    {
        if(spec.aTable[spec.i].devTable[j] == true)
        {
            spec.aTable[spec.i].curDev = j;
            spec.aTable[spec.i].devTable[j] = false;
            spec.aTable[spec.i].transDIndex =
                    devInfoList[spec.aTable[spec.i].curDev].firstTransDCubeIndex
                    - 1;
            return true;
        }
    }
    return false;
}

bool DAlgorithmRenderer::selectTransD(_Spec &spec) const
//  return "false" if no Trans-D exists
{
    int lastIndex, j;
    bool selOK;
    bool result = true;
    DLogic temp;
    if(spec.aTable[spec.i].curDev == devNum - 1)
    {
        lastIndex = transDNum - 1;
    }
    else
    {
        lastIndex =
                devInfoList[spec.aTable[spec.i].curDev+1].firstTransDCubeIndex
                - 1;
    }
    do
    {
        spec.aTable[spec.i].transDIndex++;
        if(spec.aTable[spec.i].transDIndex > lastIndex)
        {
            result = false;
        }
        else
        {
            selOK = false;
            for(j = 0; j < nodeNum; j++)
            {
                temp = transDTable[spec.aTable[spec.i].transDIndex][j];
                if(temp == DL_D || temp == DL_N)
                {
                    if(spec.tc[spec.i - 1][j] ==
                            transDTable[spec.aTable[spec.i].transDIndex][j])
                    {
                        selOK = true;
                    }
                    break;
                }
            }
        }
    }while(result && !selOK);
    if(result)  // selOK
    {
        spec.c = transDTable[spec.aTable[spec.i].transDIndex];
    }
    return result;
}

DRes DAlgorithmRenderer::dspec(DCube &resCube, int faultDIndex)
{
    DRes result = IndexTooLarge;
    int faultDNum = faultDTable.getRowNum();

    if(faultDIndex >= faultDNum)
    {
        return result;
    }

    _Spec spec;
    spec.faultDIndex = faultDIndex;

    initializeAlg(spec);
    int algStat = Intercube;
    bool interRes, implRes;
    TestNodeRes testRes;
    do
    {
        switch(algStat)
        {
        case Intercube:
            interRes = intercube(spec.tc[spec.i], spec.c, spec.tc[spec.i-1]);
            if(interRes)
            {
                implRes = implication(spec.tc[spec.i], spec.tc[spec.i]);
                if(implRes)
                {
                    testRes = testNode(spec);
                    if(testRes == Out)
                    {
                        algStat = LineConfirm;
                    }
                    else if(testRes == NoOut)
                    {
                        setTCLen(spec.i + 1, spec);
                        getNewA(spec);
                        algStat = SelectDev;
                    }
                    else
                    {
                        result = Failure;
                        algStat = End;
                    }
                }
                else
                {
                    algStat = SelectTransD;
                }
            }
            else
            {
              algStat = SelectTransD;
            }
            break;
        case LineConfirm:
            // I haven't found any necessity to perform a line confirmation here
            // so the algorithm ends directly.
            algStat = End;
            resCube.setLength(nodeNum);
            for(int j = 0; j < nodeNum; j++)
            {
                resCube[j] = spec.tc[spec.i][j];
            }
            result = DAlgorithm::Success;
            break;
        case SelectDev:
            if(selectNewDev(spec))
            {
                algStat = SelectTransD;
            }
            else
            {
                setTCLen(spec.i - 1, spec);
                if(spec.i == 0)
                {
                    algStat = End;
                    result = NoTest;
                }
                else
                {
                    algStat = SelectTransD;
                }
            }
            break;
        case SelectTransD:
            if(selectTransD(spec))
            {
                algStat = Intercube;
            }
            else
            {
                algStat = SelectDev;
            }
            break;
        }
    }while(algStat != End);
    return result;
}

#ifdef __Dalgo_debug__

void DAlgorithmRenderer::copyCube(DCube &dest, const DCube &src)
{
    for(int i = 0; i < nodeNum; i++)
    {
        dest[i] = src[i];
    }
}

void DAlgorithmRenderer::setCube(DCube &cube, const DCube &src)
{
    cube.setLength(nodeNum);
    for(int i = 0; i < nodeNum; i++)
    {
        cube[i] = src[i];
    }
}

bool DAlgorithmRenderer::cubeExists(const DCube &cube)
{
    for(int i = 0; i < nodeNum; i++)
    {
        if(cube[i] == DL_E)
        {
            return false;
        }
    }
    return true;
}

bool DAlgorithmRenderer::lineConfirm()
{
    return true;
}

void DAlgorithmRenderer::writeD(DLogic dLogic)
{
    switch(dLogic)
    {
    case DL_0:
        cout << "0";
        break;
    case DL_1:
        cout << "1";
        break;
    case DL_X:
        cout << "X";
        break;
    case DL_N:
        cout << "_";
        break;
    case DL_D:
        cout << "D";
        break;
    }
}

void DAlgorithmRenderer::showTransD()
{
    cout << "showing Trans-D ..." << endl;
    int rowNum = transDTable.getRowNum();
    int colNum = transDTable.getColNum();
    for(int i = 0; i < rowNum; i++)
    {
        for(int j = 0; j < colNum; j++)
        {
            writeD(transDTable[i][j]);
            cout << " ";
        }
        if(i % 3 == 2)
        {
            cout << endl;
        }
        else
        {
            cout << "; ";
        }
    }
    cout << endl;
}

void DAlgorithmRenderer::showFaultD()
{
    cout << "showing Fault-D ..." << endl;
    int rowNum = faultDTable.getRowNum();
    int colNum = faultDTable.getColNum();
    for(int i = 0; i < rowNum; i++)
    {
        cout << i << ": ";
        for(int j = 0; j < colNum; j++)
        {
            writeD(faultDTable[i][j]);
            cout << " ";
        }
        cout << endl;
    }
}

void DAlgorithmRenderer::showDevInfo()
{
    int len = devInfoList.getLength();
    cout << ": Device info: " << endl;
    for(int i = 0; i < len; i++)
    {
        cout << ": " << i << ": Original-"
                << devInfoList[i].firstOriginalCubeIndex
                << ", TransD-" << devInfoList[i].firstTransDCubeIndex << endl;
    }
}

bool DAlgorithmRenderer::testImplication(DCube &res, const DCube &tc)
{
    return implication(res, tc);
}

#endif