[AS3]拟柱体数值积分

/**
* 在[a, b]间的拟柱体数值积分。

* @param f 积分函数
* @param a 左界限
* @param b 右界限
* @return [a, b]间的定积分
*/

public static function cylinderInte(f:Function, a:Number, b:Number):Number {
   var h:Number = b-a;
   return (h/6)*(f(a) + 4*f( (a+b) / 2 ) + f(b));
}

加入 MXNA

今天我收到了来自 MXNA 的邮件，正式加入了 MXNA。

MXNA 是一个关于 Adobe 产品的 Blog 聚合，包含了大量的 RIA 的内容。

[AS3]辛普森数值积分

/**
* 在[a, b]间的辛普森数值积分
* @param f 积分函数
* @param a 左界限
* @param b 右界限
* @param n 分段数
* @return [a, b]间的定积分
*/

public static function simpsonInte(f:Function, a:Number, b:Number, n:int = 1024):Number {
 n*=2;//2n => n
 var h:Number = (b-a) / (n);
 var x1:Number = 0;
 var x2:Number = 0;
 n--;//2n-1 => n
 for(var i:int = 1; i i++*/) {
  x1 += f(a + i*h);
  i++;//i+1 => i
  x2 += f(a + i*h);
 }
 return (h/3)*(f(a) + f(b) + 4*x1 + 2*x2);
}

[AS3]梯形数值积分

/**
* 在[a, b]间的梯形数值积分
* @param f 被积分函数
* @param a 左界限
* @param b 右界限
* @param n 分段数
* @return [a, b]间的定积分
*/

public static function trapezoidalInte(f:Function, a:Number, b:Number,n:int = 1024):Number {
 var h:Number = (b-a) / n;
 var result:Number = 0;
 n--;//n-1 => n
 for(var i:int = 1; i<n; i++) {
  result += f(a + i*h);
 }
 return (h/2)*(f(a) + f(b) + 2*result);
}

[AS3]忽略符号的四舍五入

/**
* 忽略符号的四舍五入。
*
* AMath.rint(1.2) //-> 1
* AMath.rint(-1.2)//-> -1
* AMath.rint(1.7) //-> 2
* AMath.rint(-1.7)//-> -2
* @param v a Number
* @return Rounded Nuumber.
*/

public static function rint(v:Number):int {
 if(v > 0) {
  return int(v + 0.5);
 }
 if(v < 0) {
  return -int(-v + 0.5);
 }else{
  return 0;
 }
}

[AS3]截取 ByteArray 中某一范围的元素

/**
* 截取原始 ByteArray 中某一范围的元素构成的新 ByteArray。
* 返回的 ByteArray 包括 start 元素以及从其开始到 end 元素（但不包括该元素）的所有元素。
*
* @param bytes 原始 ByteArray
* @param result 返回指针，如果为 null，将会创建新的 ByteArray。
* @param start 开始下标，负数表示从后面开始数。
* @param end 结束下标，负数表示从后面开始数。
* @return result
*/

public static function slice(
 bytes:ByteArray, result:IDataOutput = null, 
 start:int = 0, end:int = -1):IDataOutput
{
 if(!bytes) {
  throw new ArgumentError("Param: must not be null.");
 }
 var totalLength:int = bytes.length;
 if(!result) result = new ByteArray();
 if(start<0) start = totalLength + start;
 if(end<0) end = totalLength + end;
 var length:int = end - start + 1;
 result.writeBytes(bytes, start, length);
 return result;
}

[AS3]颜色反转滤镜

需要 IBitmapFilterFactory。

package advancedflex.graphics.images.filters {
 
 import flash.filters.BitmapFilter;
 import flash.filters.ColorMatrixFilter;

 /**
  * 颜色反转工厂。
  * 
它是AFGL(Advanced Flex Graphics Library)的一部分。
  */
 public class ReversesFilterFactory implements IBitmapFilterFactory {
  
  /* The Reverses Matrix */
  private static const $MATRIX:Array = [
   -1, 0, 0, 0, 255,
    0,-1, 0, 0, 255,
    0, 0,-1, 0, 255,
    0, 0, 0, 1, 0,
  ];
  
  /**
   * 创建滤镜。
   * @return 滤镜。
   */
  public function create():BitmapFilter {
   return new ColorMatrixFilter($MATRIX);
  }
  
  /**
   * 释放滤镜工厂占用的大内存，但实际上什么也不做。
   * 调用后在调用其他方法时也不会发成错误。
   */
  public function dispose():void {
   //Do Nothing.
  }
  
  /**
   * 返回 ReversesFilterFactory 对象，
   * 它是与原始 ReversesFilterFactory 对象完全相同的副本。
   * @return ReversesFilterFactory 对象。
   */
  public function clone():IBitmapFilterFactory {
   return new ReversesFilterFactory();
  }
  
 }
}

[AS3]图像滤镜效果的接口

这个类为今后将会发布的图像滤镜效果的接口。

package advancedflex.graphics.images.filters {
 
 import flash.filters.BitmapFilter;
 
 /**
  * IBitmapFilterFactory 类是所有图像滤镜效果工厂的接口。
  * 他可以创建各种 BitmapFilter。
  * 它是AFGL(Advanced Flex Graphics Library)的一部分。
  */
 public interface IBitmapFilterFactory {
  
  /**
   * 创建滤镜。
   * @return 滤镜。
   */
  function create():BitmapFilter;
  
  /**
   * 返回 IBitmapFilterFactory 对象，
   * 它是与原始 IBitmapFilterFactory 对象完全相同的副本。
   * @return IBitmapFilterFactory 对象。
   */
  function clone():IBitmapFilterFactory;
  
  /**
   * 释放滤镜工厂占用的大内存(如果有的话)。
   * 对 BitmapFilterFactory 调用 dispose() 方法时，
   * 对此 BitmapFilterFactory 实例的方法或属性的所有后续调用都将失败，并引发异常。
   */
  function dispose():void;
 }
}

[AS3]生成呈高斯分布的伪随机数(2)

/**
* 用极坐标法(polar method)生成一个呈高斯分布的伪随机数。
*
* 这使用了 G. E. P. Box、M. E. Muller 和 G. Marsaglia 的极坐标法，
* 该方法在 Donald E. Knuth 的 The Art of Computer Programming,
* Volume 3:Seminumerical Algorithms 的第 3.4.1 节，小节 C，算法 P 中进行了描述。
* 注意，它只需调用一次 Math.log 和调用一次 Math.sqrt 就可以生成两个独立的值
*
* @param mu 平均值μ
* @param sigma 标准差σ^2
*
* @return 伪随机数。
*/

public static function getGaussian2(mu:Number = 0, sigma:Number = 1):Number {
 if (haveNextNextGaussian) {
  haveNextNextGaussian = false;
   return nextNextGaussian;
 } else {
  var v1:Number, v2:Number, s:Number;
  do {
   v1 = 2 * Math.random() - 1; // between -1.0 and 1.0
   v2 = 2 * Math.random() - 1; // between -1.0 and 1.0
    s = v1 * v1 + v2 * v2;
  } while (s >= 1 || s == 0);
  var multiplier:Number = Math.sqrt(-2 * Math.log(s)/s);
  nextNextGaussian = v2 * multiplier;
  haveNextNextGaussian = true;
  return v1*multiplier*sigma + mu;
 }
}

private static var nextNextGaussian:Number;
private static var haveNextNextGaussian:Boolean = false;

[AS3]生成呈高斯分布的伪随机数

/**
* 用雅可比变换生成一个呈高斯分布的伪随机数。
*
* @param mu 平均值μ
* @param sigma 标准差σ^2
* @return 伪随机数。
*/

public static function getGaussian(mu:Number = 0, sigma:Number = 1):Number {
 var r1:Number = Math.random();
 var r2:Number = Math.random();
 return Math.sqrt( -2*Math.log(r1) ) * Math.cos( 2*Math.PI*r2 ) * sigma+mu;
}

[AS3]根据名字得到类

/**
* 根据名字得到类。它包括使用 registerClassAlias 定义的类。
* 它相当于 Java 中的 Class.forName。
* @param name 类的名字。
* @return 类。
* @see flash.utils.getDefinitionByName
* @see flash.net.getClassByAlias
*/

public static function forName(name:String):Class {
 try {
  return getDefinitionByName(name) as Class;
 } catch(e:ReferenceError) {
  try {
   return getClassByAlias(name);
  } catch(e2:ReferenceError) {
   throw new ReferenceError("There is not such a class:<"+name+">.");
  }
 }
 return null;
}

[AS3]使用黄金分割查找法来搜索数组的元素

需要FloatUtil.equals，请参照[AS3]判断两个浮点小数的数组是否相等。

Class : advancedflex.utils.FloatArrayUtil

/**
* 使用黄金分割查找法来搜索数组的元素。
*
* @param sortedArray 排成升序(从小到大)的数组。
* @param value 要查找的值。
* @param tol 浮点小数的计算误差。
* @return 元素的下标。如果没有，则返回 -1。
*/

public static function gsearch(sortedArray:Array, value:Number, tol:Number = 1e-12):int {
 if(!sortedArray) {
  throw new ArgumentError("Param: must not be null.");
 }
 return $gsearch(sortedArray, value, tol, 0, sortedArray.length);
}

/**
 * @private
 */
private static const $LEFT_RATIO:Number = 0.6180339887498949;

/**
 * @private
 */
private static const $RIGHT_RATIO:Number = 1 - $LEFT_RATIO;

 /**
 * @private
 * 使用黄金分割查找法来搜索数组的元素。
 * 
 * @param sortedArray 排成升序(从小到大)的数组。
 * @param value 要查找的值。
 * @param tol 浮点小数的计算误差。
 * @param left 查找的最左边。
 * @param right 查找的最右边。
 * @return 元素的下标。如果没有，则返回 -1。
 */
private static function $gsearch(
 sortedArray:Array, value:Number, tol:Number,
 left:int, right:int):int 
{
 if(right - left <= 1) {
  return FloatUtil.equals(sortedArray[left], value, tol) ? left :
   FloatUtil.equals(sortedArray[right], value, tol) ? left :
   -1;
 }
 var center:int = $RIGHT_RATIO*left + $LEFT_RATIO*right
 switch(FloatUtil.compare(sortedArray[center], value, tol)) {
  case 1 :
   return $gsearch(sortedArray, value, tol, left, center);
  case -1:
   return $gsearch(sortedArray, value, tol, center, right);
  default:
   return center;
 }
}

[AS3]使用二分法查找法来搜索数组的元素

需要FloatUtil.equals，请参照[AS3]判断两个浮点小数的数组是否相等

Class : advancedflex.utils.FloatArrayUtil

/**
* 使用二分查找法来搜索数组的元素。
*
* @param sortedArray 排成升序(从小到大)的数组。
* @param value 要查找的值。
* @param tol 浮点小数的计算误差。
* @return 元素的下标。如果没有，则返回 -1。
* @throws ArgumentError 如果 sortedArray 为 null。
*/


public static function bsearch(sortedArray:Array, value:Number, tol:Number = 1e-12):int {
 if(!sortedArray) {
  throw new ArgumentError("Param: must not be null.");
 }
 return $bsearch(sortedArray, value, tol, 0, sortedArray.length-1);
}
/**
 * @private
 * 使用二分查找法来搜索数组的元素。
 * 
 * @param sortedArray 排成升序(从小到大)的数组。
 * @param value 要查找的值。
 * @param tol 浮点小数的计算误差。
 * @param left 查找的最左边。
 * @param right 查找的最右边。
 * @return 元素的下标。如果没有，则返回 -1。
 */
private static function $bsearch(
 sortedArray:Array, value:Number, tol:Number,
 left:int, right:int):int 
{
 if(right - left <= 1) {
  return FloatUtil.equals(sortedArray[left], value, tol) ? left :
   FloatUtil.equals(sortedArray[right], value, tol) ? left :
   -1;
 }
 var center:int = (left+right)/2;
 switch(FloatUtil.compare(sortedArray[center], value, tol)) {
  case 1 :
   return $bsearch(sortedArray, value, tol, left, center);
  case -1:
   return $bsearch(sortedArray, value, tol, center, right);
  default:
   return center;
 }
}

[AS3]判断两个对象的数据类型是否一样

/**
* 判断两个对象的数据类型是否一样。
*
* @param a 一个对象。
* @param b 另一个对象。
* @return 如果一样，返回 true；否则返回 false。
*/

public static function eqType(a:Object, b:Object):Boolean {
 return  a === b
  || describeType(a).@name == describeType(b).@name;
}

[AS3]两个浮点小数的数组相加

/**
* 两个浮点小数的数组相加。
* @sample addArray([1,2], [3,4]); // -> [4,6]
*
* @param a 一个浮点小数的数组。
* @param b 另一个浮点小数的数组。
* @param result 返回结果的数组，如果为 null，将会创建新的数组返回。
* @return 结果。如果 result 不为 null，将会返回 result；否则将会创建新的数组返回。
*/

public static function addArray(a:Array, b:Array, result:Array = null):Array {
 var length:int = Math.max(a.length, b.length);
 result = result || new Array(length);
 for(var i:int = 0; i < length; i++) {
  result[i] = a[i] + b[i];
 }
 return result;
}

[AS3]判断是否为闰年

/**
* 判断是否为闰年。
*
* @param date 时间。
* @return 如果是闰年返回 true；否则为 false。
*/

public static function isLeapYear(date:Date):Boolean {
 var year:int = date.fullYear;
 return (year%4 == 0 && year%100 != 0) || year%400 == 0;
}

[AS3]得到 Array 指定的元素的个数。

/**
* 得到指定的元素的个数。
*
* @param array 数组。
* @param value 元素。
* @return 个数。
* @throws ArgumentError 当 array 为 null 时。
*/

public static function count(array:Array, value:*):int {
if(!array) {
 throw new ArgumentError("Param: must not be null.");
}
var found:int = 0;
var length:int = array.length;
for(var i:int = 0; i <>

[AS3]打乱数组的排列顺序

需要 swap 函数，请参见[AS3]交换数组中的两个下标的值。

/**
* 打乱数组的排列顺序。
*
* @param array 数组。
* @return 数组本身。
*/

public static function random(array:Array):Array {
 var length:int = array.length/2 + 1;
 var last:int = array.length;
 var idx:int;
 for(var i:int = 0; i < length; i++) {
  idx = i + int(Math.random()*last);
  last--;
  swap(array, i, idx);
 }
 return array;
}

[AS3]交换数组中的两个下标的值

/**
* 交换数组中的两个下标的值。
*
* @param array 数组。
* @param idx1 一个下标。
* @param idx2 另一个下标。
*/

public static function swap(array:Array, idx1:int, idx2:int):void {
 var tmp:* = array[idx1];
 array[idx1] = array[idx2];
 array[idx2] = tmp;
}

[AS3]删除数组中的重复的元素

/**
* 删除数组中的重复的元素。顺序为第一次出现的顺序。
*
* @sample unique([1,1,2,1,3,2,1,1]) // -> [1,2,3]
* @param array 数组。
* @return 删除给与数组中的重复的元素后的新数组。
*/

public static function unique(array:Array):Array {
 var result:Array = [];
 var valueSet:Dictionary = new Dictionary(false);
 var length:int = array.length;
 for(var i:int = 0; i < length; i++) {
  if(!valueSet[array[i]]) {
   result.push(array[i]);
   valueSet[array[i]] = true;
  }
 }
 return result;
}

[AS3]执行给予的 JavaScript

/**
* 执行给予的JavaScript。
* @param src javaScript
*/

public static function evalJS(src:String):void {
 if (src != null) {
  const commentPattern:RegExp = 
   /(\/\*([^*]|[\r\n]|(\*+([^*\/]|[\r\n])))*\*+\/)|((^|[^:\/])(\/\/.*))/g;
  src = src.replace (commentPattern, "");
 }
 var u:URLRequest = new URLRequest ("javascript:eval('" + src + "');");
 navigateToURL(u,"_self");
}

[AS3]得到帧率

使用方法：

package {
 import flash.display.Sprite;
 import advancedflex.core.FPSView;
 public class TestFPS extends Sprite {
  //把FPSView 添加到enterFrame事件里，这样才能查看帧率。
  addEventListener("enterFrame", FPSView.instance.enterFrameHandler);
  //得到帧率，这个属性可以被绑定。
  trace(FPSView.instance.fps);
 }
}

源码：

/////////////////////////////////////////////////////////////////////////////
//Copyright 2007 Advanced Flex Project http://code.google.com/p/advancedflex/. 
//
//  Licensed under the Apache License, Version 2.0 (the "License");
//  you may not use this file except in compliance with the License.
//  You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
/////////////////////////////////////////////////////////////////////////////
package advancedflex.core {
 
 import flash.events.Event;
 import flash.utils.getTimer;
 
 /**
  * 查看帧率。
  */
 public class FPSView {
  //instance
  private static const $INSTANCE:FPSView = new FPSView();
  
  /**
   * 得到实例。
   * 
   * @return instance 实例。
   */
  public static function get instance():FPSView {
   return $INSTANCE;
  }
  
  //first time
  private var ft:int;
  把
  //second time
  private var st:int;
  
  [Bindable]
  /**
   * 帧率。
   */
  public var fps:int;
  
  /**
   * EnterFrame Event Handler.你必须把它添加到DisplayObject才能查看帧率。
   */
  public function enterFrameHandler(event:Event):void {
   st = getTimer();
   fps = Math.round(1000 / (st - ft));
   ft = st;
  }
 }
}

[AS3]给字符串加上N个字符使长度达到指定的值

需要repect 函数。请参见[AS3]高速重复字符串

/**
* 在左边加上N个字符，使长度达到length。比如：lpad("abc", 5, "1")//->11abc
*
* @param str 源字符串.
* @param 长度
* @param ch 字符，长度必须为1.
*
* @return 更新后的字符串.
*/

public static function lpad(str:String, length:int, ch:String = " "):String {
 if(str.length >= length) {
  return str;
 }
 if(ch.length != 1) {
  throw new SyntaxError("ch.length must be 1.");
 }
 return  repeat(ch, length - str.length) + str;
}

/**
* 在右边加上N个字符，使长度达到length。比如：rpad("abc", 5, "1")//->abc11
*
* @param str 源字符串.
* @param 长度
* @param ch 字符，长度必须为1.
*
* @return 更新后的字符串.
*/

public static function rpad(str:String, length:int, ch:String = " "):String {
 if(str.length >= length) {
  return str;
 }
 if(ch.length != 1) {
  throw new SyntaxError("ch.length must be 1.");
 }
 return  str + repeat(ch, length - str.length);
}

[AS3]高速重复字符串

/**
* 重复 str times 次。
* @param str 源字符串。
* @param times 重复次数。
* @return 结果
*/

public static function repeat(str:String, times:int):String {
 if(times <= 0) 
  return "";
 return $repeat(str, times);
}

/**
 * @private
 *
 * 重复 str times 次。
 * @param str 源字符串。
 * @param times 重复次数。
 * @return 结果
 */
private static function $repeat(str:String, times:int):String {
 /*
  *        | s       (n     = 1)
  * f(s,n)=| f(s, n/2)*2    (n % 2 = 0)
  *        | s + f[s, (n-1) / 2]*2  (n % 2 = 1)
  */
 var tmp:String;
 if(times == 1)
  return str;
 if(times % 2 == 0) {
  tmp = $repeat(str, times / 2)
  return tmp + tmp;
 } else {
  tmp = $repeat(str, (times - 1) / 2)
  return str + tmp + tmp;
 }
}

[AS3]删除字符串的空白

需要 mx.utils.StringUtil

/**
* 删除左边的空白(空格、\t、\r、\n、\f)。
* @param str 要被删除空白的字符串。
* @return 删除空白后的字符串。
*/

public static function ltrim(str:String):String {
 var startIndex:int = 0;
 while (StringUtil.isWhitespace(str.charAt(startIndex))) {
  startIndex++;
 }
 return str.slice(startIndex, -1);
}

/**
* 去掉右边的空白(空格、\t、\r、\n、\f)。
* @param str 要被删除空白的字符串。
* @return 删除空白后的字符串。
*/

public static function rtrim(str:String):String {
 var endIndex:int = str.length - 1;
 while (StringUtil.isWhitespace(str.charAt(endIndex))) {
  endIndex--;
 }
 return str.slice(0, endIndex + 1);
}

[AS3]把 ByteArray 转换为 16 进制

/**
* 把 ByteArray 转换为 16 进制。
* 格式为 "BB BB BB BB BB BB BB BB|BB BB..."，"BB" 表示一个字节。
*
* @param bytes ByteArray
* @return 把 ByteArray 转换为16进制后的字符串。
*/

public static function toHex(bytes:ByteArray):String {
 var pos:int = bytes.position;
 bytes.position = 0;
 var result:String = "";
 while(bytes.bytesAvailable >= 8) {
  result +=  $toHexNum(bytes.readUnsignedByte()) + " "
   +   $toHexNum(bytes.readUnsignedByte()) + " "
   +   $toHexNum(bytes.readUnsignedByte()) + " "
   +   $toHexNum(bytes.readUnsignedByte()) + " "
   +   $toHexNum(bytes.readUnsignedByte()) + " "
   +   $toHexNum(bytes.readUnsignedByte()) + " "
   +   $toHexNum(bytes.readUnsignedByte()) + " "
   +   $toHexNum(bytes.readUnsignedByte()) + "|";
 }
 while(bytes.bytesAvailable>1) {
  result += $toHexNum(bytes.readUnsignedByte()) + " "
 }
 if(bytes.bytesAvailable) {
  result += $toHexNum(bytes.readUnsignedByte());
 }
 bytes.position = pos;
 return result;
}

/**
 * @private
 * 
 * 把 1 个字节转换为 16 进制的字符串。
 * 
 * @param n 1 个字节。
 * @return 16 进制的字符串。
 */
private static function $toHexNum(n:uint):String {
 return n <= 0xF ? "0" + n.toString(16) : n.toString(16);
}

[AS3]判断两个对象是否相等

需要 eqByteArray 函数，请参见 [AS3]判断两个 ByteArray 是否相等。

/**
* 判断两个对象是否相等，它使用深层比较。
* @param a 一个对象。
* @param b 另一个对象。
* @return 如果相等，返回 true；否则返回 false。
*/

public static function eqObject(a:Object, b:Object):Boolean {
 if(a === b) {
  return true;
 }
 var bytesA:ByteArray = new ByteArray()
 bytesA.writeObject(a);
 var bytesB:ByteArray = new ByteArray()
 bytesB.writeObject(b);
 return eqByteArray(bytesA, bytesB);
}

[AS3]判断两个浮点小数的数组是否相等

需要 eqFloat 函数。请参见：[AS3]比较两个浮点小数

/**
* 在考虑计算误差的情况下，判断两个浮点小数的数组是否相等。
*
* @param a 一个浮点小数的数组。
* @param b 另一个浮点小数的数组。
* @param tol 允许的最大浮点小数的计算误差。
* @return 如果相等，返回 true；否则返回 false。
*/

public static function eqFloatArray(a:Array, b:Array,
    tol:Number = 1e-12):Boolean
{
    if(a.length != b.length) {
        return false;
    }
    var l:int = a.length;
    for(var i:int = 0; i < l; i++) {
        if(!eqFloat(a[i], b[i], tol)) {
            return false;
        }
    }
    return true;
}

[AS3]判断两个 ByteArray 是否相等

/**
* 判断两个 ByteArray 是否相等。
*
* @param a 一个 ByteArray。
* @param b 另一个 ByteArray。
* @return 如果相等，返回 true；否则返回 false。
*/

public static function eqByteArray(a:ByteArray, b:ByteArray):Boolean {
    if(a.length != b.length) {
        return false;
    }
    var posA:int = a.position;
    var posB:int = b.position;
    var result:Boolean = true;
    a.position = b.position = 0;
    while(a.bytesAvailable >= 4) {
        if(a.readUnsignedInt() != b.readUnsignedInt()) {
            result = false;
            break;
        }
    }
    if(result && a.bytesAvailable != 0) {
        var last:int = a.bytesAvailable;
        result =
            last == 1 ? a.readByte() == b.readByte() :
            last == 2 ? a.readShort() == b.readShort() :
            last == 3 ? a.readShort() == b.readShort()
                && a.readByte() == b.readByte() :
            true;
    }
    a.position = posA;
    b.position = posB;
    return result;
}

[AS3]比较两个浮点小数

/**
* 在考虑计算误差的情况下，判断两个浮点小数是否相等。
*
* @param a 一个浮点小数。
* @param b 另一个浮点小数。
* @param tol 允许的最大浮点小数的计算误差。
* @return 如果相等，返回 true；否则返回 false。
*/

public static function eqFloat(a:Number, b:Number,
  tol:Number = 1e-12):Boolean
{
  return Math.abs(a - b) < tol;
}

/**
* 在考虑计算误差的情况下，判断两个浮点小数的大小。
*
* @param a 一个浮点小数。
* @param b 另一个浮点小数。
* @param tol 允许的最大浮点小数的计算误差。
* @return 如果相等，返回 0；ab，返回 1。
*/

public static function compareFloat(a:Number, b:Number, 
  tol:Number = 1e-12):int
{
  return eqFloat(a, b, tol) ? 0 :
         a < b ? -1 :
         1;
}

Getting Starts

ActionScript Snippets 是一个收集 Advanced Flex Project 在开发时有用的代码、类的博客。

代码均遵循 Apache License 2.0。希望对大家有所帮助。