← Back to branch summary

~ubuntu-branches/ubuntu/precise/libav/precise-updates

« back to all changes in this revision

Viewing changes to libavutil/lls.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2012-01-12 22:30:00 UTC
  • mfrom: (1.2.8) (1.1.13 experimental)
  • Revision ID: package-import@ubuntu.com-20120112223000-cmfo7w78q13i2fd9
Tags: 4:0.8~beta2-1ubuntu1
* Merge from debian, remaining changes:
  - don't build against libdirac, lame, libopenjpeg, librtmp, 
    x264, and xvid  (all in universe)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavutil/lls.c
30
30
 
31
31
#include "lls.h"
32
32
 
33
 
void av_init_lls(LLSModel *m, int indep_count){
 
33
void av_init_lls(LLSModel *m, int indep_count)
 
34
{
34
35
    memset(m, 0, sizeof(LLSModel));
35
 
 
36
 
    m->indep_count= indep_count;
 
36
    m->indep_count = indep_count;
37
37
}
38
38
 
39
 
void av_update_lls(LLSModel *m, double *var, double decay){
40
 
    int i,j;
 
39
void av_update_lls(LLSModel *m, double *var, double decay)
 
40
{
 
41
    int i, j;
41
42
 
42
 
    for(i=0; i<=m->indep_count; i++){
43
 
        for(j=i; j<=m->indep_count; j++){
 
43
    for (i = 0; i <= m->indep_count; i++) {
 
44
        for (j = i; j <= m->indep_count; j++) {
44
45
            m->covariance[i][j] *= decay;
45
 
            m->covariance[i][j] += var[i]*var[j];
46
 
        }
47
 
    }
48
 
}
49
 
 
50
 
void av_solve_lls(LLSModel *m, double threshold, int min_order){
51
 
    int i,j,k;
52
 
    double (*factor)[MAX_VARS+1]= (void*)&m->covariance[1][0];
53
 
    double (*covar )[MAX_VARS+1]= (void*)&m->covariance[1][1];
54
 
    double  *covar_y            =  m->covariance[0];
55
 
    int count= m->indep_count;
56
 
 
57
 
    for(i=0; i<count; i++){
58
 
        for(j=i; j<count; j++){
59
 
            double sum= covar[i][j];
60
 
 
61
 
            for(k=i-1; k>=0; k--)
62
 
                sum -= factor[i][k]*factor[j][k];
63
 
 
64
 
            if(i==j){
65
 
                if(sum < threshold)
66
 
                    sum= 1.0;
67
 
                factor[i][i]= sqrt(sum);
68
 
            }else
69
 
                factor[j][i]= sum / factor[i][i];
70
 
        }
71
 
    }
72
 
    for(i=0; i<count; i++){
73
 
        double sum= covar_y[i+1];
74
 
        for(k=i-1; k>=0; k--)
75
 
            sum -= factor[i][k]*m->coeff[0][k];
76
 
        m->coeff[0][i]= sum / factor[i][i];
77
 
    }
78
 
 
79
 
    for(j=count-1; j>=min_order; j--){
80
 
        for(i=j; i>=0; i--){
81
 
            double sum= m->coeff[0][i];
82
 
            for(k=i+1; k<=j; k++)
83
 
                sum -= factor[k][i]*m->coeff[j][k];
84
 
            m->coeff[j][i]= sum / factor[i][i];
85
 
        }
86
 
 
87
 
        m->variance[j]= covar_y[0];
88
 
        for(i=0; i<=j; i++){
89
 
            double sum= m->coeff[j][i]*covar[i][i] - 2*covar_y[i+1];
90
 
            for(k=0; k<i; k++)
91
 
                sum += 2*m->coeff[j][k]*covar[k][i];
92
 
            m->variance[j] += m->coeff[j][i]*sum;
93
 
        }
94
 
    }
95
 
}
96
 
 
97
 
double av_evaluate_lls(LLSModel *m, double *param, int order){
 
46
            m->covariance[i][j] += var[i] * var[j];
 
47
        }
 
48
    }
 
49
}
 
50
 
 
51
void av_solve_lls(LLSModel *m, double threshold, int min_order)
 
52
{
 
53
    int i, j, k;
 
54
    double (*factor)[MAX_VARS + 1] = (void *) &m->covariance[1][0];
 
55
    double (*covar) [MAX_VARS + 1] = (void *) &m->covariance[1][1];
 
56
    double *covar_y                = m->covariance[0];
 
57
    int count                      = m->indep_count;
 
58
 
 
59
    for (i = 0; i < count; i++) {
 
60
        for (j = i; j < count; j++) {
 
61
            double sum = covar[i][j];
 
62
 
 
63
            for (k = i - 1; k >= 0; k--)
 
64
                sum -= factor[i][k] * factor[j][k];
 
65
 
 
66
            if (i == j) {
 
67
                if (sum < threshold)
 
68
                    sum = 1.0;
 
69
                factor[i][i] = sqrt(sum);
 
70
            } else {
 
71
                factor[j][i] = sum / factor[i][i];
 
72
            }
 
73
        }
 
74
    }
 
75
 
 
76
    for (i = 0; i < count; i++) {
 
77
        double sum = covar_y[i + 1];
 
78
 
 
79
        for (k = i - 1; k >= 0; k--)
 
80
            sum -= factor[i][k] * m->coeff[0][k];
 
81
 
 
82
        m->coeff[0][i] = sum / factor[i][i];
 
83
    }
 
84
 
 
85
    for (j = count - 1; j >= min_order; j--) {
 
86
        for (i = j; i >= 0; i--) {
 
87
            double sum = m->coeff[0][i];
 
88
 
 
89
            for (k = i + 1; k <= j; k++)
 
90
                sum -= factor[k][i] * m->coeff[j][k];
 
91
 
 
92
            m->coeff[j][i] = sum / factor[i][i];
 
93
        }
 
94
 
 
95
        m->variance[j] = covar_y[0];
 
96
 
 
97
        for (i = 0; i <= j; i++) {
 
98
            double sum = m->coeff[j][i] * covar[i][i] - 2 * covar_y[i + 1];
 
99
 
 
100
            for (k = 0; k < i; k++)
 
101
                sum += 2 * m->coeff[j][k] * covar[k][i];
 
102
 
 
103
            m->variance[j] += m->coeff[j][i] * sum;
 
104
        }
 
105
    }
 
106
}
 
107
 
 
108
double av_evaluate_lls(LLSModel *m, double *param, int order)
 
109
{
98
110
    int i;
99
 
    double out= 0;
 
111
    double out = 0;
100
112
 
101
 
    for(i=0; i<=order; i++)
102
 
        out+= param[i]*m->coeff[order][i];
 
113
    for (i = 0; i <= order; i++)
 
114
        out += param[i] * m->coeff[order][i];
103
115
 
104
116
    return out;
105
117
}
106
118
 
107
119
#ifdef TEST
108
120
 
109
 
#include <stdlib.h>
110
121
#include <stdio.h>
 
122
#include <limits.h>
 
123
#include "lfg.h"
111
124
 
112
 
int main(void){
 
125
int main(void)
 
126
{
113
127
    LLSModel m;
114
128
    int i, order;
 
129
    AVLFG lfg;
115
130
 
 
131
    av_lfg_init(&lfg, 1);
116
132
    av_init_lls(&m, 3);
117
133
 
118
 
    for(i=0; i<100; i++){
 
134
    for (i = 0; i < 100; i++) {
119
135
        double var[4];
120
136
        double eval;
121
 
        var[0] = (rand() / (double)RAND_MAX - 0.5)*2;
122
 
        var[1] = var[0] + rand() / (double)RAND_MAX - 0.5;
123
 
        var[2] = var[1] + rand() / (double)RAND_MAX - 0.5;
124
 
        var[3] = var[2] + rand() / (double)RAND_MAX - 0.5;
 
137
 
 
138
        var[0] = (av_lfg_get(&lfg) / (double) UINT_MAX - 0.5) * 2;
 
139
        var[1] = var[0] + av_lfg_get(&lfg) / (double) UINT_MAX - 0.5;
 
140
        var[2] = var[1] + av_lfg_get(&lfg) / (double) UINT_MAX - 0.5;
 
141
        var[3] = var[2] + av_lfg_get(&lfg) / (double) UINT_MAX - 0.5;
125
142
        av_update_lls(&m, var, 0.99);
126
143
        av_solve_lls(&m, 0.001, 0);
127
 
        for(order=0; order<3; order++){
128
 
            eval= av_evaluate_lls(&m, var+1, order);
 
144
        for (order = 0; order < 3; order++) {
 
145
            eval = av_evaluate_lls(&m, var + 1, order);
129
146
            printf("real:%9f order:%d pred:%9f var:%f coeffs:%f %9f %9f\n",
130
 
                var[0], order, eval, sqrt(m.variance[order] / (i+1)),
131
 
                m.coeff[order][0], m.coeff[order][1], m.coeff[order][2]);
 
147
                   var[0], order, eval, sqrt(m.variance[order] / (i + 1)),
 
148
                   m.coeff[order][0], m.coeff[order][1],
 
149
                   m.coeff[order][2]);
132
150
        }
133
151
    }
134
152
    return 0;