*              Algorithm can be used either to static or dynamic rate matching. */int wcdma_rate_dematch(           double Inputs[],     /* IN: input data symbol vector */           int nInputs,         /* IN: length of input data vector */           double max_punct_ratio,  /* IN: Max. ratio to puncture/repetite */           int target_block_size,   /* IN: block size to match */           double outData[])    /* OUT: Dematched output */{    double block_ratio;    double temp_double_vector[MAX_BLOCK_SIZE];    double temp_output_vector[MAX_BLOCK_SIZE];    double *temp_input;    int current_input_size;    double *out_ptr;    int output_size;    int i, j, k, l, x, y, z, puncture;    /*     * Check the size of input block related to the allowed     * output block size.     * Check whether we need to puncture or repeat bits.     */    block_ratio = (target_block_size - nInputs) / (float)nInputs;    if (block_ratio > max_punct_ratio) {        printf("wcdma_rate_match: puncture/repetition ratio %g too large.\n",               block_ratio);        return(-1);    }    puncture = (block_ratio > 0) ? FALSE : TRUE;    /*     * Now puncture, if needed.     * Puncture every z'th bit, until input fits to TC block.     */    temp_input = Inputs;    if (puncture == TRUE) {        x = nInputs;        y = nInputs - target_block_size;        if (y <= 1) {            memcpy(temp_output_vector, temp_input, nInputs*sizeof(double));            output_size = nInputs;        }        while (y > 1) {            z = (int)ceil((double)x/(double)y);            k = x / z;            l = 0;            /*             * Puncture every z'th bit.             */            for (i=0; i < x; i++) {                if ((i % z) != (z-1)) {                    temp_double_vector[l++] = temp_input[i];                }            }            x -= k;            y -= k;            memcpy(temp_output_vector, temp_double_vector, sizeof(double)*l);            output_size = l;            temp_input = temp_output_vector;        }        if (y == 1) {            output_size -= 1;            memcpy(outData, temp_output_vector+1, sizeof(double)*(output_size));        } else {            memcpy(outData, temp_output_vector, sizeof(double)*(output_size));        }    } else {        /*         * Repetition.         */        x = nInputs;        y = target_block_size - nInputs;        current_input_size = nInputs;        if (y <= 1) {            memcpy(temp_output_vector, temp_input, nInputs*sizeof(double));            output_size = nInputs;        }        while (y > 1) {            z = (int)ceil((double)x/(double)y);            k = x / z;            l = 0;            /*             * Repeat every z'th bit.             */            for (i=0; i < current_input_size; i++) {                if ((i % z) != (z-1)) {                    temp_double_vector[l++] = temp_input[i];                } else {                    temp_double_vector[l++] = temp_input[i];                    temp_double_vector[l++] = temp_input[i];                }            }            x -= k;            y -= k;            memcpy(temp_output_vector, temp_double_vector, sizeof(double)*l);            output_size = l;            temp_input = temp_output_vector;            current_input_size = l;        } /* while */        if (y == 1) {            output_size += 1;            temp_output_vector[output_size-1] =                                   temp_output_vector[output_size-2];            out_ptr = &(outData[0]);        } else {            out_ptr = outData;        }        memcpy(out_ptr, temp_output_vector, sizeof(double)*output_size);    } /* else for repetition */    return(0);} /* wcdma_rate_dematch *//* -------------------------------------------------------------------- *//* * Static rate matching algorithm for a Transport Channel (TC). * The algorithm gets a vector of allowable bits per block, * size of input bit block, maximum puncturing ratio (1=all, 0.0=none). * Depending on the given pucturing ratio, it either punctures  * or repeats bits.  */int wcdma_srate_match4TC(        int no_of_allowed_sizes,/* size of allowed_bit_sizes -vector */	int allowed_block_sizes[],/* vector of allowed block sizes */	float max_punct_ratio,	/* max puncturing ratio (0.0 .. 1.0) */ 	int input_size,		/* size of input block */	int input_data[],	/* vector of input data bits */	int *output_size,	/* size of output block */	int output_data[])	/* vector of output data bits */{    int i, j, k, x, y, z, puncture;    int ratio_to_upper_size, ratio_to_lower_size, l;    int temp_int_vector[MAX_BLOCK_SIZE];    int temp_output_vector[MAX_BLOCK_SIZE];    int *temp_input;    int *out_ptr;    int upper_block_size, lower_block_size;    int current_input_size;    float lbs;    float needed_punct_ratio;    /*     * Check the size of input block related to the allowed     * output blocks.     * Check whether we need to puncture or repeat bits.     */    i = 0;    while ( (i < no_of_allowed_sizes) &&            (input_size > allowed_block_sizes[i] ) ) {        i++;    }    if (i < no_of_allowed_sizes) { /* between two output sizes */        lower_block_size = allowed_block_sizes[i-1];        upper_block_size = allowed_block_sizes[i];        ratio_to_upper_size  = upper_block_size / input_size;        /*         * If input block fits N (N>1) times to output block,         * then repeat every bit N times.         */        if ( (ratio_to_upper_size > 1) && (input_size != lower_block_size) ) {            l = 0;	    for (j=0; j < input_size; j++) {		for (k=0; k < ratio_to_upper_size; k++) {                    temp_output_vector[l++] = input_data[j];                }	    }        }        lbs = (float)lower_block_size;        needed_punct_ratio = ((float)input_size - lbs) / (float)input_size;;        puncture = (needed_punct_ratio > max_punct_ratio) ? FALSE : TRUE;    }    else /* bigger than maximum output size */    {        lower_block_size = allowed_block_sizes[i];        upper_block_size = NO_UPPER_BLOCK_SIZE;        ratio_to_lower_size  = (float)input_size / (float)lower_block_size;        if (ratio_to_lower_size > max_punct_ratio) {            fprintf(stderr,                    "wcdma_srate_match4TC: Too much pucturing required.\n");            return(-1);        } else {            puncture = TRUE;        }    }        /*     * Now puncture, if needed.     * Puncture every z'th bit, until input fits to TC block.     */    temp_input = input_data;    if (puncture == TRUE) {        x = input_size;        y = input_size - lower_block_size;        while (y > 1) {            z = (int)ceil((double)x/(double)y);            k = x / z;            l = 0;            /*             * Puncture every z'th bit.             */            for (i=0; i < x; i++) {                if ((i % z) != (z-1)) {                    temp_int_vector[l++] = temp_input[i];                }            }            x -= k;            y -= k;            memcpy(temp_output_vector, temp_int_vector, sizeof(int)*l);            *output_size = l;            temp_input = temp_output_vector;        }        if (y == 1) *output_size -= 1;        memcpy(output_data, temp_output_vector, sizeof(int)*(*output_size));    } else {        /*         * Could not puncture, do repetition to fill up to upper block size.         */        x = input_size;        y = upper_block_size - input_size;        current_input_size = input_size;        while (y > 1) {            z = (int)ceil((double)x/(double)y);            k = x / z;            l = 0;            /*             * Repeat every z'th bit.             */            for (i=0; i < current_input_size; i++) {                if ((i % z) != (z-1)) {                    temp_int_vector[l++] = temp_input[i];                } else {                    temp_int_vector[l++] = temp_input[i];                    temp_int_vector[l++] = temp_input[i];                }            }            x -= k;            y -= k;            memcpy(temp_output_vector, temp_int_vector, sizeof(int)*l);            *output_size = l;            temp_input = temp_output_vector;            current_input_size = l;        } /* while */        if (y == 1) {            *output_size += 1;            output_data[0] = temp_output_vector[0];            out_ptr = &(output_data[1]);        } else {            out_ptr = output_data;        }        memcpy(out_ptr, temp_output_vector, sizeof(int)*l);    } /* else for repetition */    return(0);} /* wcdma_srate_match4TC *//* ----------------------------------------------------------- */