1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
/*
* Revision 1.1 1996/08/19 22:32:00 jaf
* Initial revision
*
*/
/* -- translated by f2c (version 19951025).
You must link the resulting object file with the libraries:
-lf2c -lm (in that order)
*/
#include "f2c.h"
extern int invert_(integer *order, real *phi, real *psi, real *rc);
/* **************************************************************** */
/* INVERT Version 45G */
/*
* Revision 1.1 1996/08/19 22:32:00 jaf
* Initial revision
* */
/* Revision 1.3 1996/03/18 20:52:47 jaf */
/* Just added a few comments about which array indices of the arguments */
/* are used, and mentioning that this subroutine has no local state. */
/* Revision 1.2 1996/03/13 16:51:32 jaf */
/* Comments added explaining that none of the local variables of this */
/* subroutine need to be saved from one invocation to the next. */
/* Eliminated a comment from the original, describing a local array X */
/* that appeared nowhere in the code. */
/* Revision 1.1 1996/02/07 14:47:20 jaf */
/* Initial revision */
/* **************************************************************** */
/* Invert a covariance matrix using Choleski decomposition method. */
/* Input: */
/* ORDER - Analysis order */
/* PHI(ORDER,ORDER) - Covariance matrix */
/* Indices (I,J) read, where ORDER .GE. I .GE. J .GE. 1.*/
/* All other indices untouched. */
/* PSI(ORDER) - Column vector to be predicted */
/* Indices 1 through ORDER read. */
/* Output: */
/* RC(ORDER) - Pseudo reflection coefficients */
/* Indices 1 through ORDER written, and then possibly read.
*/
/* Internal: */
/* V(ORDER,ORDER) - Temporary matrix */
/* Same indices written as read from PHI. */
/* Many indices may be read and written again after */
/* initially being copied from PHI, but all indices */
/* are written before being read. */
/* NOTE: Temporary matrix V is not needed and may be replaced */
/* by PHI if the original PHI values do not need to be preserved. */
/* Subroutine */ int invert_(integer *order, real *phi, real *psi, real *rc)
{
/* System generated locals */
integer phi_dim1, phi_offset, i__1, i__2, i__3;
real r__1, r__2;
/* Local variables */
real save;
integer i__, j, k;
real v[100] /* was [10][10] */;
/* Arguments */
/* LPC Configuration parameters: */
/* Frame size, Prediction order, Pitch period */
/* Parameters/constants */
/* Local variables that need not be saved */
/* Decompose PHI into V * D * V' where V is a triangular matrix whose */
/* main diagonal elements are all 1, V' is the transpose of V, and */
/* D is a vector. Here D(n) is stored in location V(n,n). */
/* Parameter adjustments */
--rc;
--psi;
phi_dim1 = *order;
phi_offset = phi_dim1 + 1;
phi -= phi_offset;
/* Function Body */
i__1 = *order;
for (j = 1; j <= i__1; ++j) {
i__2 = *order;
for (i__ = j; i__ <= i__2; ++i__) {
v[i__ + j * 10 - 11] = phi[i__ + j * phi_dim1];
}
i__2 = j - 1;
for (k = 1; k <= i__2; ++k) {
save = v[j + k * 10 - 11] * v[k + k * 10 - 11];
i__3 = *order;
for (i__ = j; i__ <= i__3; ++i__) {
v[i__ + j * 10 - 11] -= v[i__ + k * 10 - 11] * save;
}
}
/* Compute intermediate results, which are similar to RC's */
if ((r__1 = v[j + j * 10 - 11], abs(r__1)) < 1e-10f) {
goto L100;
}
rc[j] = psi[j];
i__2 = j - 1;
for (k = 1; k <= i__2; ++k) {
rc[j] -= rc[k] * v[j + k * 10 - 11];
}
v[j + j * 10 - 11] = 1.f / v[j + j * 10 - 11];
rc[j] *= v[j + j * 10 - 11];
/* Computing MAX */
/* Computing MIN */
r__2 = rc[j];
r__1 = min(r__2,.999f);
rc[j] = max(r__1,-.999f);
}
return 0;
/* Zero out higher order RC's if algorithm terminated early */
L100:
i__1 = *order;
for (i__ = j; i__ <= i__1; ++i__) {
rc[i__] = 0.f;
}
/* Back substitute for PC's (if needed) */
/* 110 DO J = ORDER,1,-1 */
/* PC(J) = RC(J) */
/* DO I = 1,J-1 */
/* PC(J) = PC(J) - PC(I)*V(J,I) */
/* END DO */
/* END DO */
return 0;
} /* invert_ */
|
