窗函数的C语言实现
一般的讲数字信号处理的书中都会提到窗函数。大多数只会提及其中的几种。这里我把这些窗都用C语言实现了一下，都不复杂，但如果要自己去弄也挺费时间。所有函数都用Matlab验证了。包括以下窗：
/*窗类型*/
typedef enum
{
Bartlett = ,
BartLettHann,
BlackMan,
BlackManHarris,
Bohman,
Chebyshev,
FlatTop,
Gaussian,
Hamming,
Hann,
Kaiser,
Nuttal,
Parzen,
Rectangular,
Taylor,
Triangular,
Tukey
}winType;
别的不多说了，直接上干货。
/*
*file WindowFunction.h
*author Vincent Cui
*e-mail whcui1987@163.com
*version 0.3
*data 31-Oct-2014
*brief 各种窗函数的C语言实现
*/ #ifndef _WINDOWFUNCTION_H_
#define _WINDOWFUNCTION_H_ #include "GeneralConfig.h" #define BESSELI_K_LENGTH 10 #define FLATTOPWIN_A0 0.215578995
#define FLATTOPWIN_A1 0.41663158
#define FLATTOPWIN_A2 0.277263158
#define FLATTOPWIN_A3 0.083578947
#define FLATTOPWIN_A4 0.006947368 #define NUTTALL_A0 0.3635819
#define NUTTALL_A1 0.4891775
#define NUTTALL_A2 0.1365995
#define NUTTALL_A3 0.0106411 #define BLACKMANHARRIS_A0 0.35875
#define BLACKMANHARRIS_A1 0.48829
#define BLACKMANHARRIS_A2 0.14128
#define BLACKMANHARRIS_A3 0.01168 dspErrorStatus taylorWin(dspUint_16 N, dspUint_16 nbar, dspDouble sll, dspDouble **w);
dspErrorStatus triangularWin(dspUint_16 N, dspDouble **w);
dspErrorStatus tukeyWin(dspUint_16 N, dspDouble r, dspDouble **w);
dspErrorStatus bartlettWin(dspUint_16 N, dspDouble **w);
dspErrorStatus bartLettHannWin(dspUint_16 N, dspDouble **w);
dspErrorStatus blackManWin(dspUint_16 N, dspDouble **w);
dspErrorStatus blackManHarrisWin(dspUint_16 N, dspDouble **w);
dspErrorStatus bohmanWin(dspUint_16 N, dspDouble **w);
dspErrorStatus chebyshevWin(dspUint_16 N, dspDouble r, dspDouble **w);
dspErrorStatus flatTopWin(dspUint_16 N, dspDouble **w);
dspErrorStatus gaussianWin(dspUint_16 N, dspDouble alpha, dspDouble **w);
dspErrorStatus hammingWin(dspUint_16 N, dspDouble **w);
dspErrorStatus hannWin(dspUint_16 N, dspDouble **w);
dspErrorStatus kaiserWin(dspUint_16 N, dspDouble beta, dspDouble **w);
dspErrorStatus nuttalWin(dspUint_16 N, dspDouble **w);
dspErrorStatus parzenWin(dspUint_16 N, dspDouble **w);
dspErrorStatus rectangularWin(dspUint_16 N, dspDouble **w); #endif
WindowFunction.h
/*
*file WindowFunction.c
*author Vincent Cui
*e-mail whcui1987@163.com
*version 0.3
*data 31-Oct-2014
*brief 各种窗函数的C语言实现
*/ #include "WindowFunction.h"
#include "GeneralConfig.h"
#include "MathReplenish.h"
#include "math.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h> /*函数名：taylorWin
*说明：计算泰勒窗。泰勒加权函数
*输入：
*输出：
*返回：
*调用：prod()连乘函数
*其它：用过以后，需要手动释放掉*w的内存空间
* 调用示例：ret = taylorWin(99, 4, 40, &w); 注意此处的40是正数 表示-40dB
*/
dspErrorStatus taylorWin(dspUint_16 N, dspUint_16 nbar, dspDouble sll, dspDouble **w)
{
dspDouble A;
dspDouble *retDspDouble;
dspDouble *sf;
dspDouble *result;
dspDouble alpha,beta,theta;
dspUint_16 i,j; /*A = R cosh(PI, A) = R*/
A = (dspDouble)acosh(pow((dspDouble)10.0,(dspDouble)sll/20.0)) / PI;
A = A * A; /*开出存放系数的空间*/
retDspDouble = (dspDouble *)malloc(sizeof(dspDouble) * (nbar - ));
if(retDspDouble == NULL)
return DSP_ERROR;
sf = retDspDouble; /*开出存放系数的空间*/
retDspDouble = (dspDouble *)malloc(sizeof(dspDouble) * N);
if(retDspDouble == NULL)
return DSP_ERROR;
result = retDspDouble; alpha = prod(, , (nbar - ));
alpha *= alpha;
beta = (dspDouble)nbar / sqrt( A + pow((nbar - 0.5), ) );
for(i = ; i <= (nbar - ); i++)
{
*(sf + i - ) = prod(,,(nbar - + i)) * prod(,,(nbar - - i));
theta = ;
for(j = ; j <= (nbar - ); j++)
{
theta *= - (dspDouble)(i * i) / ( beta * beta * ( A + (j - 0.5) * (j - 0.5)) );
}
*(sf + i - ) = alpha * (dspDouble)theta / (*(sf + i - ));
} /*奇数阶*/
if((N % ) == )
{
for(i = ; i < N; i++)
{
alpha = ;
for(j = ; j <= (nbar - ); j++)
{
alpha += (*(sf + j - )) * cos( * PI * j * (dspDouble)(i - ((N-)/))/N );
}
*(result + i) = + * alpha;
}
}
/*偶数阶*/
else
{
for(i = ; i < N; i++)
{
alpha = ;
for(j = ; j <= (nbar - ); j++)
{
alpha += (*(sf + j - )) * cos( PI * j * (dspDouble)( * (i - (N/)) + ) / N );
}
*(result + i) = + * alpha; }
}
*w = result;
free(sf); return DSP_SUCESS; } /*
*函数名：triangularWin
*说明：计算三角窗函数
*输入：
*输出：
*返回：
*调用：
*其它：用过以后，需要手动释放掉*w的内存空间
* 调用示例：ret = triangularWin(99, &w);
*/
dspErrorStatus triangularWin(dspUint_16 N, dspDouble **w)
{
dspDouble *ptr;
dspUint_16 i; ptr = (dspDouble *)malloc(N * sizeof(dspDouble));
if(ptr == NULL)
return DSP_ERROR; /*阶数为奇*/
if((N % ) == )
{
for(i = ; i < ((N - )/); i++)
{
*(ptr + i) = * (dspDouble)(i + ) / (N + );
}
for(i = ((N - )/); i < N; i++)
{
*(ptr + i) = * (dspDouble)(N - i) / (N + );
}
}
/*阶数为偶*/
else
{
for(i = ; i < (N/); i++)
{
*(ptr + i) = (i + i + ) * (dspDouble) / N;
}
for(i = (N/); i < N; i++)
{
*(ptr + i) = *(ptr + N - - i);
}
}
*w = ptr; return DSP_SUCESS;
} /*
*函数名：tukeyWin
*说明：计算tukey窗函数
*输入：
*输出：
*返回：linSpace()
*调用：
*其它：用过以后，需要手动释放掉*w的内存空间
* 调用示例：ret = tukeyWin(99, 0.5, &w);
*/
dspErrorStatus tukeyWin(dspUint_16 N, dspDouble r, dspDouble **w)
{
dspErrorStatus retErrorStatus;
dspUint_16 index;
dspDouble *x,*result,*retPtr;
dspDouble alpha; retErrorStatus = linSpace(, , N, &x);
if(retErrorStatus == DSP_ERROR)
return DSP_ERROR; result = (dspDouble *)malloc(N * sizeof(dspDouble));
if(result == NULL)
return DSP_ERROR; /*r <= 0 就是矩形窗*/
if(r <= )
{
retErrorStatus = rectangularWin(N, &retPtr);
if(retErrorStatus == DSP_ERROR)
return DSP_ERROR;
/*将数据拷出来以后，释放调用的窗函数的空间*/
memcpy(result, retPtr, ( N * sizeof(dspDouble)));
free(retPtr);
}
/*r >= 1 就是汉宁窗*/
else if(r >= )
{
retErrorStatus = hannWin(N, &retPtr);
if(retErrorStatus == DSP_ERROR)
return DSP_ERROR;
/*将数据拷出来以后，释放调用的窗函数的空间*/
memcpy(result, retPtr, ( N * sizeof(dspDouble)));
free(retPtr);
}
else
{
for(index = ; index < N; index++)
{
alpha = *(x + index);
if(alpha < (r/))
{
*(result + index) = (dspDouble)( + cos( * PI * (dspDouble)(alpha - (dspDouble)r/)/r))/;
}
else if((alpha >= (r/)) && (alpha <( - r/)))
{
*(result + index) = ;
}
else
{
*(result + index) = (dspDouble)( + cos( * PI * (dspDouble)(alpha - + (dspDouble)r/)/r))/;
} }
} free(x); *w = result; return DSP_SUCESS; } /*
*函数名：bartlettWin
*说明：计算bartlettWin窗函数
*输入：
*输出：
*返回：
*调用：
*其它：用过以后，需要手动释放掉*w的内存空间
* 调用示例：ret = bartlettWin(99, &w);
*/
dspErrorStatus bartlettWin(dspUint_16 N, dspDouble **w)
{
dspDouble *ret;
dspUint_16 n; ret = (dspDouble *)malloc(N * sizeof(dspDouble));
if(ret == NULL)
return DSP_ERROR; for(n = ; n < ( N - ) / ; n++)
{
*(ret + n) = * (dspDouble)n / (N - );
} for(n = ( N - ) / ; n < N; n++)
{
*(ret + n) = - * (dspDouble)n / (( N - ));
} *w = ret; return DSP_SUCESS;
} /*
*函数名：bartLettHannWin
*说明：计算bartLettHannWin窗函数
*输入：
*输出：
*返回：
*调用：
*其它：用过以后，需要手动释放掉*w的内存空间
* 调用示例：ret = bartLettHannWin(99, &w);
*/
dspErrorStatus bartLettHannWin(dspUint_16 N, dspDouble **w)
{
dspUint_16 n;
dspDouble *ret; ret = (dspDouble *)malloc(N * sizeof(dspDouble));
if(ret == NULL)
return DSP_ERROR;
/*奇*/
if(( N % ) == )
{
for(n = ; n < N; n++)
{
*(ret + n) = 0.62 - 0.48 * myAbs( ( (dspDouble)n / ( N - ) ) - 0.5 ) + 0.38 * cos( * PI * ( ((dspDouble)n / ( N - ) ) - 0.5 ) );
}
for(n = ; n < (N-)/; n++)
{
*(ret + n) = *(ret + N - - n);
}
}
/*偶*/
else
{
for(n = ; n < N; n++)
{
*(ret + n) = 0.62 - 0.48 * myAbs( ( (dspDouble)n / ( N - ) ) - 0.5 ) + 0.38 * cos( * PI * ( ((dspDouble)n / ( N - ) ) - 0.5 ) );
}
for(n = ; n < N/; n++)
{
*(ret + n) = *(ret + N - - n);
}
} *w = ret; return DSP_SUCESS; } /*
*函数名：blackManWin
*说明：计算blackManWin窗函数
*输入：
*输出：
*返回：
*调用：
*其它：用过以后，需要手动释放掉*w的内存空间
* 调用示例：ret = blackManWin(99, &w);
*/
dspErrorStatus blackManWin(dspUint_16 N, dspDouble **w)
{
dspUint_16 n;
dspDouble *ret;
ret = (dspDouble *)malloc(N * sizeof(dspDouble));
if(ret == NULL)
return DSP_ERROR; for(n = ; n < N; n++)
{
*(ret + n) = 0.42 - 0.5 * cos( * PI * (dspDouble)n / ( N - )) + 0.08 * cos( * PI * ( dspDouble )n / ( N - ) );
} *w = ret; return DSP_SUCESS;
} /*
*函数名：blackManHarrisWin
*说明：计算blackManHarrisWin窗函数
*输入：
*输出：
*返回：
*调用：
*其它：用过以后，需要手动释放掉*w的内存空间
* 调用示例：ret = blackManHarrisWin(99, &w);
* minimum 4-term Blackman-harris window -- From Matlab
*/
dspErrorStatus blackManHarrisWin(dspUint_16 N, dspDouble **w)
{
dspUint_16 n;
dspDouble *ret; ret = (dspDouble *)malloc(N * sizeof(dspDouble));
if(ret == NULL)
return DSP_ERROR; for(n = ; n < N; n++)
{
*(ret + n) = BLACKMANHARRIS_A0 - BLACKMANHARRIS_A1 * cos( * PI * (dspDouble)n / (N) ) + \
BLACKMANHARRIS_A2 * cos( * PI * (dspDouble)n/ (N) ) - \
BLACKMANHARRIS_A3 * cos( * PI * (dspDouble)n/ (N) );
} *w = ret; return DSP_SUCESS;
} /*
*函数名：bohmanWin
*说明：计算bohmanWin窗函数
*输入：
*输出：
*返回：
*调用：
*其它：用过以后，需要手动释放掉*w的内存空间
* 调用示例：ret = bohmanWin(99, &w);
*/
dspErrorStatus bohmanWin(dspUint_16 N, dspDouble **w)
{
dspUint_16 n;
dspDouble *ret;
dspDouble x;
ret = (dspDouble *)malloc(N * sizeof(dspDouble));
if(ret == NULL)
return DSP_ERROR; for(n = ; n < N; n++)
{
x = - + n * (dspDouble) / ( N - ) ;
/*取绝对值*/
x = x >= ? x : ( x * ( - ) );
*(ret + n) = ( - x ) * cos( PI * x) + (dspDouble)( / PI) * sin( PI * x);
} *w = ret; return DSP_SUCESS;
} /*
*函数名：chebyshevWin
*说明：计算chebyshevWin窗函数
*输入：
*输出：
*返回：
*调用：
*其它：用过以后，需要手动释放掉*w的内存空间
* 调用示例：ret = chebyshevWin(99,100, &w);
*/
dspErrorStatus chebyshevWin(dspUint_16 N, dspDouble r, dspDouble **w)
{
dspUint_16 n,index;
dspDouble *ret;
dspDouble x, alpha, beta, theta, gama; ret = (dspDouble *)malloc(N * sizeof(dspDouble));
if(ret == NULL)
return DSP_ERROR; /*10^(r/20)*/
theta = pow((dspDouble), (dspDouble)(myAbs(r)/));
beta = pow(cosh(acosh(theta)/(N - )),);
alpha = - (dspDouble) / beta; if((N % ) == )
{
/*计算一半的区间*/
for( n = ; n < ( N + ) / ; n++ )
{
gama = ;
for(index = ; index < n; index++)
{
x = index * (dspDouble)( N - - * n + index) /(( n - index ) * (n + -index));
gama = gama * alpha * x + ;
}
*(ret + n) = (N - ) * alpha * gama;
} theta = *( ret + (N - )/ );
*ret = ; for(n = ; n < ( N + ) / ; n++ )
{
*(ret + n) = (dspDouble)(*(ret + n)) / theta;
} /*填充另一半*/
for(; n < N; n++)
{
*(ret + n) = ret[N - n - ];
}
}
else
{
/*计算一半的区间*/
for( n = ; n < ( N + ) / ; n++ )
{
gama = ;
for(index = ; index < n; index++)
{
x = index * (dspDouble)( N - - * n + index) /(( n - index ) * (n + -index));
gama = gama * alpha * x + ;
}
*(ret + n) = (N - ) * alpha * gama;
} theta = *( ret + (N/) - );
*ret = ; for(n = ; n < ( N + ) / ; n++ )
{
*(ret + n) = (dspDouble)(*(ret + n)) / theta;
} /*填充另一半*/
for(; n < N; n++)
{
*(ret + n) = ret[N - n - ];
}
} *w = ret; return DSP_SUCESS;
} /*
*函数名：flatTopWin
*说明：计算flatTopWin窗函数
*输入：
*输出：
*返回：
*调用：
*其它：用过以后，需要手动释放掉*w的内存空间
* 调用示例：ret = flatTopWin(99, &w);
*/
dspErrorStatus flatTopWin(dspUint_16 N, dspDouble **w)
{
dspUint_16 n;
dspDouble *ret;
ret = (dspDouble *)malloc(N * sizeof(dspDouble));
if(ret == NULL)
return DSP_ERROR; for(n = ; n < N; n++)
{
*(ret + n) = FLATTOPWIN_A0 - FLATTOPWIN_A1 * cos( * PI * (dspDouble)n / (N - )) +\
FLATTOPWIN_A2 * cos( * PI * (dspDouble)n / (N - )) -\
FLATTOPWIN_A3 * cos( * PI * (dspDouble)n / (N - )) +\
FLATTOPWIN_A4 * cos( * PI * (dspDouble)n / (N - ));
} *w = ret; return DSP_SUCESS;
} /*
*函数名：gaussianWin
*说明：计算gaussianWin窗函数
*输入：
*输出：
*返回：
*调用：
*其它：用过以后，需要手动释放掉*w的内存空间
* 调用示例：ret = gaussianWin(99,2.5, &w);
*/
dspErrorStatus gaussianWin(dspUint_16 N, dspDouble alpha, dspDouble **w)
{
dspUint_16 n;
dspDouble k, beta, theta;
dspDouble *ret; ret = (dspDouble *)malloc(N * sizeof(dspDouble));
if(ret == NULL)
return DSP_ERROR; for(n =; n < N; n++)
{
if((N % ) == )
{
k = n - (N - )/;
beta = * alpha * (dspDouble)k / (N - );
}
else
{
k = n - (N)/;
beta = * alpha * (dspDouble)k / (N - );
} theta = pow(beta, );
*(ret + n) = exp((-) * (dspDouble)theta / );
} *w = ret; return DSP_SUCESS;
} /*
*函数名：hammingWin
*说明：计算hammingWin窗函数
*输入：
*输出：
*返回：
*调用：
*其它：用过以后，需要手动释放掉*w的内存空间
* 调用示例：ret = hammingWin(99, &w);
*/
dspErrorStatus hammingWin(dspUint_16 N, dspDouble **w)
{
dspUint_16 n;
dspDouble *ret;
ret = (dspDouble *)malloc(N * sizeof(dspDouble));
if(ret == NULL)
return DSP_ERROR; for(n = ; n < N; n++)
{
*(ret + n) = 0.54 - 0.46 * cos ( * PI * ( dspDouble )n / ( N - ) );
} *w = ret; return DSP_SUCESS;
} /*
*函数名：hannWin
*说明：计算hannWin窗函数
*输入：
*输出：
*返回：
*调用：
*其它：用过以后，需要手动释放掉*w的内存空间
* 调用示例：ret = hannWin(99, &w);
*/
dspErrorStatus hannWin(dspUint_16 N, dspDouble **w)
{
dspUint_16 n;
dspDouble *ret;
ret = (dspDouble *)malloc(N * sizeof(dspDouble));
if(ret == NULL)
return DSP_ERROR; for(n = ; n < N; n++)
{
*(ret + n) = 0.5 * ( - cos( * PI * (dspDouble)n / (N - )));
} *w = ret; return DSP_SUCESS;
} /*
*函数名：kaiserWin
*说明：计算kaiserWin窗函数
*输入：
*输出：
*返回：
*调用：besseli()第一类修正贝塞尔函数
*其它：用过以后，需要手动释放掉*w的内存空间
* 调用示例：ret = kaiserWin(99, 5, &w);
*/
dspErrorStatus kaiserWin(dspUint_16 N, dspDouble beta, dspDouble **w)
{
dspUint_16 n;
dspDouble *ret;
dspDouble theta; ret = (dspDouble *)malloc(N * sizeof(dspDouble));
if(ret == NULL)
return DSP_ERROR; for(n = ; n < N; n++)
{
theta = beta * sqrt( - pow( ( ( * (dspDouble)n/(N -)) - ), ) );
*(ret + n) = (dspDouble)besseli(, theta, BESSELI_K_LENGTH) / besseli(, beta, BESSELI_K_LENGTH);
} *w = ret; return DSP_SUCESS;
} /*
*函数名：nuttalWin
*说明：计算nuttalWin窗函数
*输入：
*输出：
*返回：
*调用：
*其它：用过以后，需要手动释放掉*w的内存空间
* 调用示例：ret = nuttalWin(99, &w);
*/
dspErrorStatus nuttalWin(dspUint_16 N, dspDouble **w)
{
dspUint_16 n;
dspDouble *ret; ret = (dspDouble *)malloc(N * sizeof(dspDouble));
if(ret == NULL)
return DSP_ERROR; for(n = ; n < N; n++)
{
*(ret + n) =NUTTALL_A0 - NUTTALL_A1 * cos( * PI * (dspDouble)n / (N - )) +\
NUTTALL_A2 * cos( * PI * (dspDouble)n / (N - )) -\
NUTTALL_A3 * cos( * PI * (dspDouble)n / (N - )); } *w = ret; return DSP_SUCESS;
} /*
*函数名：parzenWin
*说明：计算parzenWin窗函数
*输入：
*输出：
*返回：
*调用：
*其它：用过以后，需要手动释放掉*w的内存空间
* 调用示例：ret = parzenWin(99, &w);
*/
dspErrorStatus parzenWin(dspUint_16 N, dspDouble **w)
{
dspUint_16 n;
dspDouble *ret;
dspDouble alpha,k; ret = (dspDouble *)malloc(N * sizeof(dspDouble));
if(ret == NULL)
return DSP_ERROR; if(( N % ) == )
{
for(n = ; n < N; n++)
{
k = n - (N - ) / ;
alpha = * (dspDouble)myAbs(k) / N;
if(myAbs(k) <= (N - ) / )
{
*(ret + n) = - * pow(alpha,) + * pow(alpha, );
}
else
{
*(ret + n) = * pow( ( - alpha), );
} }
}
else
{
for(n = ; n < N; n++)
{
k = n - (N - ) / ;
alpha = * (dspDouble)myAbs(k) / N;
if(myAbs(k) <= (dspDouble)(N -) / )
{
*(ret + n) = - * pow(alpha,) + * pow(alpha, );
}
else
{
*(ret + n) = * pow( ( - alpha), );
} }
} *w = ret; return DSP_SUCESS;
} /*
*函数名：rectangularWin
*说明：计算rectangularWin窗函数
*输入：
*输出：
*返回：
*调用：
*其它：用过以后，需要手动释放掉*w的内存空间
* 调用示例：ret = rectangularWin(99, &w);
*/
dspErrorStatus rectangularWin(dspUint_16 N, dspDouble **w)
{
dspUint_16 n;
dspDouble *ret; ret = (dspDouble *)malloc(N * sizeof(dspDouble));
if(ret == NULL)
return DSP_ERROR; for(n = ; n < N; n++)
{
*(ret + n) = ;
} *w = ret; return DSP_SUCESS;
}
WindowFunction.c
欢迎多交流！
窗函数的C语言实现的更多相关文章
- 单位冲击响应与频响以及FIR实现代码（C语言）（转）
源:FIR数字滤波器C语言 1.单位冲击响应与频响 就如同之前所说的一样,使用下图所示的单位冲击响应,所设计的滤波器,是无法实现的. 现在,让我们看看其这个滤波器的频响.所谓频响,就是计算其单位冲击响 ...
- C语言 · 高精度加法
问题描述 输入两个整数a和b,输出这两个整数的和.a和b都不超过100位. 算法描述 由于a和b都比较大,所以不能直接使用语言中的标准数据类型来存储.对于这种问题,一般使用数组来处理. 定义一个数组A ...
- Windows server 2012 添加中文语言包(英文转为中文)（离线）
Windows server 2012 添加中文语言包(英文转为中文)(离线) 相关资料: 公司环境:亚马孙aws虚拟机 英文版Windows2012 中文SQL Server2012安装包,需要安装 ...
- iOS开发系列--Swift语言
概述 Swift是苹果2014年推出的全新的编程语言,它继承了C语言.ObjC的特性,且克服了C语言的兼容性问题.Swift发展过程中不仅保留了ObjC很多语法特性,它也借鉴了多种现代化语言的特点,在 ...
- C语言 · Anagrams问题
问题描述 Anagrams指的是具有如下特性的两个单词:在这两个单词当中,每一个英文字母(不区分大小写)所出现的次数都是相同的.例如,"Unclear"和"Nuclear ...
- C语言 · 字符转对比
问题描述 给定两个仅由大写字母或小写字母组成的字符串(长度介于1到10之间),它们之间的关系是以下4中情况之一: 1:两个字符串长度不等.比如 Beijing 和 Hebei 2:两个字符串不仅长度相 ...
- JAVA语言中的修饰符
JAVA语言中的修饰符 -----------------------------------------------01--------------------------------------- ...
- Atitit 项目语言的选择 java c#.net php??
Atitit 项目语言的选择 java c#.net php?? 1.1. 编程语言与技术,应该使用开放式的目前流行的语言趋势1 1.2. 从个人职业生涯考虑,java优先1 1.3. 从项目实际来 ...
- 【开源】简单4步搞定QQ登录，无需什么代码功底【无语言界限】
说17号发超简单的教程就17号,qq核审通过后就封装了这个,现在放出来~~ 这个是我封装的一个开源项目:https://github.com/dunitian/LoTQQLogin ————————— ...
随机推荐
- web.xml加载顺序详解
一. 1.启动tomcat启动web项目,首先读取web.xml文件中<context-param>和<listener> 2.容器创建一个ServletContext(ser ...
- CSS3弹性盒模型布局模块
原文:http://robertnyman.com/2010/12/02/css3-flexible-box-layout-module-aka-flex-box-introduction-and-d ...
- vvv
すぎやま(杉山) ハイコンテンツコンテスト assortedアクセント・音節as・sórt・ed 発音記号/‐ṭɪd/音声を聞く [形容詞]1分類した,仕分けした.2〈ビスケットなど〉詰め合わせの.用 ...
- Android TextView文字超出一屏不能显示其它的文字 解决方案
在android上面让TextView 过多的文字实现有滚动条,之前想简单了以为设置TextView的属性就可以实现,结果还是需要ScrollView配合使用,才能达到滚动条的效果有两种方式实现, 一 ...
- IE9下报错，错误: “JSON”未定义
今天在公司运行的代码好好的,但是拿回家里以后就报错了 结果是IE9,没有设为兼容模式,唉,微软导出都是坑啊.
- rsyslog 配置详解
格式:: 日志设备(类型).(连接符号)日志级别 日志处理方式(action) 日志设备(可以理解为日志类型): ------------------------ auth –pam产生的日志 aut ...
- 2014第16周三CSS布局再学习摘录
今天尝试写了下前端页面,费了不少时间,做出的结果仍然惨不忍睹,感觉很简单的几个页面,在现有框架多个样式混杂下就是感觉很不自在随意,晚上回来又看了些div+css方面的基础知识. 1.CSS的class ...
- poj1547---结构数组
题意:老师发给每个学生的橡皮泥相同,找出谁抢了谁的橡皮泥 思路:结构数组存储每个学生的橡皮总量,和名字 /* 结构数组存储用户信息--只放名称和体积 while输入循环复用长宽高变量 for循环求所有 ...
- org/apache/commons/pool/impl/GenericObjectPool异常的解决办法
org/apache/commons/pool/impl/GenericObjectPool异常的解决办法 webwork+spring+hibernate框架的集成, 一启动Tomcat服务器就出了 ...
- Andrew Ng Machine learning Introduction
1. 机器学习的定义:Machine learning is programming computers to optimize a performance criterion(优化性能标准) usi ...