Mượn tý đất diễn đàn cho tiện, khỏi gửi mail mọt gì cho phiền. Copy rồi paste vào file Fixed.java là xong. :)
package com.darKeRa.midp.math;
/**
* <p>Title: Class for fixed-point calculations in J2ME & J2SE applications (MIDP 1.0/CLDC 1.0 where float or double types are not available or J2SE to optimized the speed of Float calculation)</p>
* <p>Description: It makes fixed-point calculations via integer numbers</p>
* <p>Copyright: Kijuto Riddle Copyright (c) 2004</p>
* <p>Company: darKeRa</p>
* <p>License: GNU General Public License & Free for use only for non-commercial purpose</p>
* <p>You are free to use all or part of this class but don't forget to read and follow the GNU General Public License</p>
* <p>Please append my copyright information com.darKeRa.midp.math.Fixed (C) by Kijuto Riddle on ‘About’ screen of your product</p>
* <p>If you have web site please share this class for everyone.</p>
* <p>That's all, thank you!</p>
* @author Kijuto Riddle
* @version 2.03
*/
/**
* Fixed Point Math
* Kijuto Riddle
* Version 2.03
*
*
* Su dung 16 bit lam phan integer co dau, dau cua Fixed la dau cua integer
* (chu y dau khi Int == 0)
* Su dung 16 bit tiep theo la phan Fraction khong dau, gia tri Fraction = low16bit / 2^16
*
* val = 16 + 16 = 32 bit;
* dau cua val == dau cua Int == dau cua Fixed
*
* :: Version 2.0 changes:
* Don't use the construction methods but use assign methods
* Warning: The method assign(int vInt) replace by setData(int v)
* The method parseInt(int vInt) replace by assign(int vInt)
* Optimized the mul, mulBy, div, divBy method
* add pow(int p) method
* add sqrt() method
* bugs fixed and optimized toSring() method
*
*:: Version 2.02 changes:
* Replace the assign(int vInt, int vFrac) // keep it in the comments
* with assign(int vFracDiv, int vDiv)
* Fix the const define too ...
* Optimized the assign(int vInt, int vFracDiv, int vDiv)
* New ways to comment the usage of assign methods
* add int sign() method: return the sign of fixed
* add Fixed angleOptimize() method: optimize the angle value to (-Pi,Pi]
*
*:: Version 2.03 changes:
* Optimized the toString(): don't create the String Object, but return the string it self
*
* :: Version 2.04 changes:
* Optimized all methods :)
*
*/
final public class Fixed
{
final static public Fixed POSINF = new Fixed().assign(Short.MAX_VALUE,Short.MAX_VALUE-Short.MIN_VALUE);
final static public Fixed NEGINF = new Fixed().assign(Short.MIN_VALUE+1,Short.MAX_VALUE-Short.MIN_VALUE);
final static public Fixed ERROR = new Fixed().setData(NEGINF.val+1);
final static public Fixed SQRT2 = new Fixed().assign(1, 27146, 65536);
final static public Fixed SQRT3 = new Fixed().assign(1, 47976, 65536);
final static public Fixed PI = new Fixed().assign(3, 9279, 65536);
final static public Fixed ZERO = new Fixed();
final static public Fixed ONE = new Fixed().assign(1);
final static public Fixed E = new Fixed().assign(2, 47073, 65536);
final static public Fixed LN10 = new Fixed().assign(2, 19830, 65536);
final static public Fixed PIdiv2 = PI.div(2);
final static public Fixed PIdiv3 = PI.div(3);
final static public Fixed PIdiv4 = PI.div(4);
final static public Fixed PIdiv6 = PI.div(6);
final static public Fixed PIdiv8 = PI.div(8);
final static public Fixed PIdiv12 = PI.div(12);
final static public Fixed PImul2 = PI.mul(2);
final static public Fixed PImul4 = PI.mul(4);
public int val;
public Fixed(){
}
public Fixed setData(int d){
// :: this.val = v;
val = d;
return this;
}
/*public Fixed assign(){
// :: this = 0;
val = 0;
return this;
}/**/
public Fixed assign(int Int){
// :: this = Int.0
val = Int<<16;
return this;
}
/*public Fixed assign(int vInt, int vFrac)
{
// :: this = vInt + vFrac/0xFFFF
// Make sure that vFrac is positive and less than 2^16=65536=0xFFFF
if (vInt<0)
val = -(((-vInt)<<16) | (vFrac&0xFFFF));
else
val = (vInt<<16) | (vFrac&0xFFFF);
return this;
}/*/
public Fixed assign(int vFracDiv, int vDiv){
// :: this = 0 + vFracDiv/vDiv
// Make sure that:
// 0 < vDiv <= 2^16
// |vFracDiv| < 2^16=65536=0xFFFF
// |vFracDiv| < vDiv
if (vFracDiv<0)
val = -((((-vFracDiv)<<16)/vDiv)&0xFFFF);
else
val = ( (vFracDiv <<16)/vDiv)&0xFFFF;
return this;
}
public Fixed assign(int vInt, int vFracDiv, int vDiv){
// :: this = vInt + vFracDiv/vDic;
// Make sure that:
// 0 < vDiv <= 2^16
// 0 <= vFracDiv < 2^16=65536=0xFFFF
// vFracDiv < vDiv
if (vInt<0)
val = -(((-vInt)<<16) | (((vFracDiv<<16)/(vDiv))&0xFFFF));
else
val = (vInt<<16) | (((vFracDiv<<16)/(vDiv))&0xFFFF);
return this;
}
public Fixed assign(Fixed f){
// :: this = f;
val = f.val;
return this;
}
public Fixed shiftL(int i){
Fixed ret =new Fixed();
ret.val = val<<i;
return ret;
}
public Fixed shiftR(int i){
Fixed ret =new Fixed();
ret.val = val>>i;
return ret;
}
public Fixed beShiftL(int i){
val<<=i;
return this;
}
public Fixed beShiftR(int i){
val>>=i;
return this;
}
public Fixed shiftAdd(int l, int m){
Fixed ret =new Fixed();
ret.val = (val<<l) + (val<<m);
return ret;
}
public Fixed shiftSub(int l, int m){
Fixed ret =new Fixed();
ret.val = (val<<l) - (val<<m);
return ret;
}
public Fixed beShiftAdd(int l, int m){
val = (val<<l) + (val<<m);
return this;
}
public Fixed beShiftSub(int l, int m){
val = (val<<l) - (val<<m);
return this;
}
public int getInt(){
if (this.val<0)
return -((-val)>>16);
else
return (val>>16);
}
public int getFrac(){
return (val<0?-val:val)&0xFFFF;
}
public String toString(int nbp){
if (val==POSINF.val) return "Positive Infinity";
if (val==NEGINF.val) return "Negative Infinity";
if (val==ERROR.val) return "Error";
int vInt = this.getInt();
long vFrac = this.getFrac();
long LIMIT = Long.MAX_VALUE/10;
StringBuffer strBuff = new StringBuffer(nbp+5);
if ( val<0 && vInt==0 ) strBuff.append('-');
strBuff.append(vInt);
strBuff.append(".");
int i=0;
for(; i<nbp && (vFrac<LIMIT); i++)
{
strBuff.append((vFrac*=10)>>16);
vFrac &= 0xFFFF;
}
int len = strBuff.length();
for (int j=1; j<i && (strBuff.charAt(len-j)=='0'); j++)
strBuff.deleteCharAt(len-j);
return strBuff.toString();
}
public String toString(){
return toString(13);
}
public Fixed getNeg(){
// :: return -this
Fixed ret =new Fixed();
ret.val = -val;
return ret;
}
public Fixed beNeg(){
// :: this = -this;
val = -val;
return this;
}
public Fixed plus(Fixed f){
// :: return (this + f)
Fixed ret =new Fixed();
ret.val = val+f.val;
return ret;
}
public Fixed plus(int i){ ///////////////////////
// :: return (this + i)
Fixed ret =new Fixed();
ret.val = val+(i<<16);
return ret;
}
public Fixed add(Fixed f){
// :: this += f
val += f.val;
return this;
}
public Fixed add(int i){
// :: this += i;
val += i<<16;
return this;
}
public Fixed minus(Fixed f){
// :: return (this - f)
Fixed ret =new Fixed();
ret.val = val - f.val;
return ret;
}
public Fixed minus(int i){
// :: return (this - i)
Fixed ret =new Fixed();
ret.val = val-(i<<16);
return ret;
}
public Fixed sub(Fixed f){
val -= f.val;
return this;
}
public Fixed sub(int i){
val -= i<<16;
return this;
}
public Fixed mul(Fixed f){
Fixed ret =new Fixed();
ret.val = (int)((val*(long)f.val)>>16);
return ret;
}
public Fixed mul(int i){
Fixed ret =new Fixed();
ret.val = val*i;
return ret;
}
public Fixed mulBy(Fixed f){
val = (int)((val*(long)f.val)>>16);
return this;
}
public Fixed mulBy(int i){
val *= i;
return this;
}
public Fixed div(Fixed f){
Fixed ret =new Fixed();
ret.val = (int)((((long)val)<<16)/f.val);
return ret;
}
public Fixed div(int i){
Fixed ret =new Fixed();
ret.val = val/i;
return ret;
}
public Fixed divBy(Fixed f){
val = (int)((((long)val)<<16)/f.val) ;
return this;
}
public Fixed divBy(int i){
val /= i;
return this;
}
public Fixed pow(int p){
if (val==0) return new Fixed().assign(ZERO);
if (p==0) return new Fixed().assign(ONE);
if (p==1) return new Fixed().assign(this);
Fixed f = new Fixed().assign(this);
for (int i=p-1;i>0;i--)
f.mulBy(this);
return f;
}
public Fixed sqrt(){
if (val<0) return new Fixed().assign(ERROR);
if (val==0) return new Fixed().assign(ZERO);
if (val==ONE.val) return new Fixed().assign(ONE);
int sp = 0;
boolean inv = false;
Fixed a,b;
Fixed tmp = new Fixed();
if (val<ONE.val){
tmp = invert();
inv = true;
}else
tmp.assign(this);
while (tmp.val>(16<<16)){ //while (tmp.great(16)){
sp++;
tmp.val>>=4; //tmp.divBy(16);
}
a = new Fixed().assign(2);
for (int i=3; i>0; i--){ // change this number higher to more accurate, and vice versa
b = tmp.div(a);
a.add(b).val>>=1; //a.add(b).divBy(2);
}
while (sp-->0)
a.val<<=2; //a.mulBy(4);
if (inv)
a.beInvert();
return a;
}
public Fixed invert(){
return ONE.div(this);
}
public Fixed beInvert(){
return this.assign(ONE.div(this));
}
public Fixed abs(){
Fixed ret =new Fixed();
ret.val = val<0?-val:val;
return ret;
}
public Fixed beAbs(){
val = val<0?-val:val;
return this;
}
public int round(){
if (val>0)
return ( getFrac()>=0x8000?(getInt()+1):getInt() );
else
return ( getFrac()>=0x8000?(getInt()-1):getInt() );
}
public boolean isNegative(){
return val<0;
}
public boolean isPositive(){
return val>0;
}
public int sign(){
return val<0?-1:1;
}
/*public boolean great( Fixed f ){
return val>f.val;
}/**/
/*public boolean great( int i ){
return val>(i<<16);
}/**/
/*public boolean less( Fixed f ){
return val<f.val;
}/**/
/*public boolean less( int i ){
return val<(i<<16);
}/**/
/*public boolean equal( Fixed f ){
return val==f.val;
}/**/
/*public boolean equal( int i ){
return val==(i<<16);
}/**/
public Fixed angleOptimize(){
while ( val > PI.val )
sub(PImul2);
while ( val <= -PI.val )
add(PImul2);
return this;
}
public Fixed sin(){
while ( val > PI.val )
sub(PImul2);
if ( val < 0 ) return this.getNeg().sin().getNeg();
if ( val > PIdiv2.val ) return PI.minus(this).sin();
if ( val == PIdiv2.val ) return ONE;
Fixed result = new Fixed().assign(this);
Fixed m = this.mul(this).mulBy(this);
result.sub(m.div(6));
m.mulBy(this).mulBy(this);
result.add(m.div(120));
m.mulBy(this).mulBy(this);
result.sub(m.div(5040));
return result;
}
public Fixed cos(){
while ( val > PI.val )
sub(PImul2);
if ( val < 0 ) return this.getNeg().cos();
if ( val > PIdiv2.val ) return PI.minus(this).cos().getNeg();
if ( val == PIdiv2.val ) return ZERO;
Fixed result = new Fixed().assign(1);
Fixed m0 = this.mul(this);
result.sub(m0.shiftR(1)); //result.sub(m0.div(2));
Fixed m = m0.mul(m0);
result.add(m.div(24));
m.mulBy(m0);
result.sub(m.div(720));
return result;
}
public Fixed tan(){
Fixed c = cos();
Fixed s = sin();
if ( c.val == 0 )
if ( s.val < 0 )
return NEGINF;
else return POSINF;
return (s.divBy(c));
}
public Fixed toDeg(){
return this.mul(180).divBy(PI);
}
public Fixed toRad(){
return this.mul(PI).divBy(180);
}
/*public Fixed atan()
{
boolean signChange = false;
boolean invert = false;
int sp = 0;
Fixed x2,a,x = new Fixed().assign(this);
if (x.less(ZERO))
{
x.beNeg();
signChange = true;
}
if (x.great(ONE))
{
x.beInvert();
invert = true;
}
while(x.great(PIdiv12))
{
sp++;
a = x.plus(SQRT3);
a.beInvert();
x.mulBy(SQRT3);
x.sub(ONE);
x.mulBy(a);
}
x2 = x.mul(x);
a = x2.plus(new Fixed().assign(1,26790));
a = new Fixed().assign(0,36644).divBy(a);
a.add(new Fixed().assign(0,39525));
a.sub(new Fixed().assign(0,3382).mulBy(x2));
a.mulBy(x);
// process until sp=0
while(sp>0)
{
a.add(PIdiv6);
sp--;
}
if (invert) a = PIdiv2.minus(a);
if (signChange) a.beNeg();
//
return a;
}/**/
}