c数组错误 – 期望元素被初始化,但它们不是,并且我的setter有时

资源

评论已删除.

#include <assert.h>
#include <float.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define CHECK_SUBSCRIPT(x,n_samples)   assert((x) >= 0 && (x) < (n_samples) * n_states)

typedef enum { false,true } bool;
typedef double (*prob_function_def)(char,char,bool);

int n_states = 17;
int n_observations = 17;
char states[17] =
    { 'X','0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char observations[17] =
    { 'X','F'};

void viterbi_log (
                char *samples,int n_samples,char *best_path,prob_function_def prior,prob_function_def transition,prob_function_def emission,bool debug
             )
{
    printf("nviterbi...n");

    int i,j,max_state_index;
    char state_i,state_j,sample_t;
    double trans_p,max_p;

    double *viterbi_table = malloc(sizeof(double) * n_samples * n_states);
    int *best_path_table = malloc(sizeof(int) * n_samples * n_states);

    for (int n33 = 0; n33 < n_samples * n_states; n33++)
    {
        CHECK_SUBSCRIPT(n33,n_samples);
        viterbi_table[n33] = 3.14159;
        best_path_table[n33] = 314159;
    }

    if (debug) printf("nInitialization:n");
    for (i = 0; i < n_states; i++)
    {
        state_i = states[i];
        sample_t = samples[0];
        CHECK_SUBSCRIPT(i*n_samples,n_samples);
        viterbi_table[i*n_samples]
            = prior(state_i,true);
        if (debug)
        {
            printf("t");
            printf("log(prior[%c]) + log(emission[%c][%c]) = %en",sample_t,viterbi_table[i*n_samples]);
        }
    }

    if (debug) printf("nForward:n");
    for (t = 1; t < n_samples; t++)
    {
        sample_t = samples[t];
        if (debug) printf("t=%d => sample=%cn",sample_t);
        for (i = 0; i < n_states; i++)
        {
            state_i = states[i];
            max_state_index = 0;
            max_p = -DBL_MAX;

            for (j = 0; j < n_states; j++)
            {
                state_j = states[j];
                CHECK_SUBSCRIPT(((t-1)*n_samples)+j,n_samples);
                trans_p = viterbi_table[((t - 1) * n_samples) + j]
                    + transition(state_i,true)
                    + emission(sample_t,true);
                if (trans_p > max_p)
                {
                    max_state_index = j;
                    max_p = trans_p;
                }
            }

            CHECK_SUBSCRIPT(t*n_samples+i,n_samples);
            viterbi_table[t * n_samples + i] = max_p;
            best_path_table[t * n_samples + i] = max_state_index;
            printf("tbest_path_table[%d][%d] or [%d] = %d => %dn",max_state_index);
        }

        if (debug)
        {
            printf("best_path,[ ");
            for (i = 0; i < n_states; i++)
            {
                CHECK_SUBSCRIPT(t*n_samples+i,n_samples);
                printf("[%d],best_path_table[t * n_samples + i]);
            }
            printf("]n");
        }
    }

    if (debug)
    {
        printf("nbest path table:n");
        for (t = n_samples - 1; t > 0; t--)
        {
            printf("t=%d,t);
            for (i = 0; i < n_states; i++)
            {
                CHECK_SUBSCRIPT(t*n_samples+i,best_path_table[t * n_samples + i]);
            }
            printf("]n");
        }
    }

    free(viterbi_table);
    free(best_path_table);
}

double prior_prob (char state_i,char state_j,bool log_prob)
{
    if (!log_prob)
        return 0.25;
    else
        return -1.3862943611198906;
}

double transition_prob (char state_i,bool log_prob)
{
    if (!log_prob)
    {
        if (state_i == 0 && state_j == 0)
            return 0.9;
        else if (state_i == 0 || state_j == 0)
            return 0.1;
        else if (state_i == state_j)
            return 0.9;
        else
            return 0.1;
    }
    else
    {
        if (state_i == 0 && state_j == 0)
            return -0.10536051565782628;
        else if (state_i == 0 || state_j == 0)
            return -2.3025850929940455;
        else if (state_i == state_j)
            return -0.10536051565782628;
        else
            return -2.3025850929940455;
    }
}

double emission_prob (char observation,char state,bool log_prob)
{
    if (!log_prob)
    {
        if (state == observation)
            return 0.8;
        else
            return 0.2;
    }
    else
    {
        if (state == observation)
            return -0.2231435513142097;
        else
            return -1.6094379124341003;
    }
}

void dtmf_example()
{
    bool debug = true;
    char *samples = "XXXXXXXXXXXXXX6X66XXXXXXXXXXXXXXXXXXXXX";
    int n_samples = strlen(samples);
    char *best_path = malloc(sizeof(int) * n_samples);

    viterbi_log(samples,n_samples,best_path,&prior_prob,&transition_prob,&emission_prob,debug);

    printf("nbest path = { ");
    for (int t = 0; t < n_samples; t++)
        printf("%d ",best_path[t]);
    printf("}n");
}

int main(void)
{
    dtmf_example();
    return 0;
}

断言：

best_path_table[13][16] or [637] = 0 => 0
best_path_table[14][16] or [638] = 0 => 0
best_path_table[15][16] or [639] = 0 => 0
best_path_table[16][16] or [640] = 0 => 0
best_path,[ [624],0 [625],0 [626],0 [627],0 [628],0 [629],0 [630],0 [631],7 [632],0 [633],0 [634],0 [635],0 [636],0 [637],0 [638],0 [639],0 [640],0 ]
t=17 => sample=6
Assertion failed: ((t*n_samples+i) >= 0 && (t*n_samples+i) < (n_samples) * n_states),function viterbi_log,file viterbi3.c,line 89.
Abort trap: 6

这是CHECK_SUBSCRIPT：

CHECK_SUBSCRIPT(t*n_samples+i,n_samples);
        viterbi_table[t * n_samples + i] = max_p;
        best_path_table[t * n_samples + i] = max_state_index;