나만 유용한 클래스6 NumberUtils.as

Number와 관련된 유틸 클래스이다.

이것도 예전 2.0때부터 써오던 클래스모음이다.
최근에 한번 수정을 하긴 했지만 여전히 개선될 것들이 있긴 하다.
그래도 역시 나름 쓸만 하다. ㅎㅎㅎ

 

package oddeye.utils
{
	import flash.display.DisplayObject;
	import flash.geom.Point;
	import flash.geom.Rectangle;
	import oddeye.control.Debug;
	
	public class NumberUtils
	{
		
		/**
		 * 인자값 타입이 Number 인지 체크
		 * @param	data
		 * @return
		 */
		public static function getIsNumber( data:* ):Boolean
		{
			return  ( Number( data ) is Number ) ? true : false;
		}
		
		/**
		 * 데이터 값 Number 체크 후에 값 리턴~
		 * @param	value
		 * @return
		 */
		public static function getNumberValue( value:Number ):Number
		{
			if  ( value is Number )
			{
				return  Number( value );
			}
			return  NaN;
		}
		
		
		/**
		 * 총 합계 구하기
		 * @param	datas
		 * @return
		 */
		public static function getSum( datas:Array ):Number
		{
			var total:Number=0;
			var len:int = datas.length;
			
			for  ( var i:int=0; i < datas.length; i++ )
			{
				if  ( NumberUtils.getIsNumber( datas[ i ] ) )
				{
					total+=Number( datas[ i ] );
				}
				else
				{
					continue;
				}
			}
			return  total;
		}
		
		/**
		 * 최대값을 구하고 그 최대값의 한계치를 구한다.
		 * 예를 들어 입력한 배열로 최대값이 100819 이렇게 나왔다면 한계치는 200000 처럼 나오게 된다.
		 * @param	data 수치값들이 들어가 있는 배열~
		 * @return
		 */
		public static function getMaxValueToLimit( data:Array ):Number
		{
			var nums:Number = NumberUtils.getMax( data );
			var numLen:int = String( nums ).length;
			var indexNum:String= String( nums ).charAt( 0 );
			var idx:int = -1;
			while  ( ++idx < numLen - 1 )
			{
				indexNum=indexNum + "9";
			}
			return  Number( indexNum )+1;
		}
		
		
		/**
		 * 최대값 구하기
		 * @param	data
		 * @return
		 */
		public static function getMax( data:Array ):Number
		{
			
			var maxData:Number = -1;
			var dataLen:int = data.length;
			var clones:Array = [];
			
			for  ( var i:int = 0; i < dataLen; i++ )
			{
				var splitText:String = StringUtils.getSplitTxt( data[ i ], "," );
				
				if  ( NumberUtils.getIsNumber( splitText ) )
				{
					clones.push( Number( splitText ) );
				}
				
			}
			maxData=ArrayUtils.getMaxValue( clones );
			clones.length=0;
			clones=null;
			
			return  maxData;
		}
		
		public static function getNumbersToMax( ... args ):Number
		{
			//public static const NUMERIC:uint = 16 - Array 클래스에 문자-문자열 정렬이 아닌 숫자 정렬 방식을 지정합니다
			//public static const RETURNINDEXEDARRAY:uint = 8 - 정렬을 통해 배열 인덱스로 구성된 배열을 반환하도록 지정합니다.
			return  ArrayUtils.getMaxValue( args ); /////////////////// items[ items.sort( Array.NUMERIC | Array.RETURNINDEXEDARRAY )[ items.length - 1 ] ];
		}
		
		
		/**
		 * 최소, 최대 범위값 지정
		 * @param	offset - 수치값
		 * @param	max - 최대범위값
		 * @param	min - 최소범위값
		 * @return
		 */
		public static function getRange( offset:Number, max:Number, min:Number ):Number
		{
			
			if  ( offset <= min )
				offset=min;
			
			if  ( offset >= max )
				offset=max;
			
			return  offset;
		}
		
		
		/**
		 * 카운트값  증감, 차감 시킴~
		 * @param	count 지정한 카운트 값
		 * @param	len  최대 length 값
		 * @param	rightDirect 좌우클릭, 업다운클릭, 차감증감을 뜻함~
		 * @param	countLoop 0~최대값 사이를 계속 롤링할지여부~
		 * @return
		 */
		public static function getCount( count:int, len:int, rightDirect:Boolean = true, countLoop:Boolean = false ):int
		{
			
			if  ( rightDirect )
				count++;
			else
				count--;
			
			//countLoop 가 true이면 0카운트에서 
			//차감하면 최종length값이 적용되어서 카운트 롤링이 된다.
			if  ( countLoop )
			{
				if  ( count > len )
					count=0;
				
				if  ( count < 0 )
					count=len;
			}
			else
			{
				if  ( count > len )
					count=len;
				
				if  ( count <= 0 )
					count=0;
			}
			
			return  count;
		}
		
		/**
		 * integer값 판단~
		 * @param	value 적용
		 * @return
		 * @example NumberUtils.getIsInteger( 1.5643 ) ///false;
		 *               NumberUtils.getIsInteger( 21 ) ////true;
		 */
		public static function getIsInteger( value:Number ):Boolean
		{
			return  ( value % 1 ) == 0;
		}
		
		
		/**
		 * 짝수 유무 -  & 1로 대입된 값을 연산
		 * @param	value 적용값
		 * @return
		 * @example NumberUtils.getIsEven( 32 ) //true
		 *               NumberUtils.getIsEven( 11 )//false
		 */
		public static function getIsEven( value:Number ):Boolean
		{
			//& 연산은 기본적으로 두수의 비트를 연산하여 서로 1일때 1을 반환하고 그렇지 않은 경우 0을 반환
			//비트의 첫자리가 0으로 시작하는 수는 보통 짝수~00000010(2), 00000100(4), 00001000(8), 00010000(16)......
			//그렇기에 홀수 & 1 은 1을 반환, 짝수 & 1은 0을 반환~
			return  ( value & 1 ) == 0;
		}
		
		
		/**
		 *
		 * 홀짝수 구분
		 * @param	n - 적용할 수치
		 * @return
		 *
		 */
		public static function getIsOdd( value:Number ):Boolean
		{
			//var oddNum:Boolean = ( value % 2 != 0 ) ? true : false;
			return  !NumberUtils.getIsEven( value );
		}
		
		
		/**
		 * 소수( 1과 자기자신만으로 나누어 떨어지는 자연수)  유무
		 * @param	value
		 * @return
		 */
		public static function getIsPrime( value:Number ):Boolean
		{
			// 1, 2는 기본적으로 소수
			if  ( value == 1 || value == 2 )
				return  true;
			
			//1, 2외에 짝수는 소수가 아님~
			if  ( NumberUtils.getIsEven( value ) )
				return  false;
			
			//제곱근을 구해서 그 수많큼 반복하여 나머지가 0인지 판단( 0 이면 소수가 아님 )
			var s:Number = Math.sqrt( value );
			
			for  ( var i:Number = 3; i <= s; i++ )
			{
				if  ( value % i == 0 )
					return  false;
			}
			return  true;
		}
		
		/**
		 *
		 * 소수점 제한하기
		 * @param	n - 적용할 수치
		 * @param	limit - 제한되는 소수점
		 * @return
		 *
		 */
		public static function getDecimal( num:Number, limit:Number ):Number
		{
			// 10을 limit 자리수만큼 제곱한다.
			var p:Number = Math.pow( 10, limit );
			
			//p(10을 limit만큽제곱된 수)를 num과 곱한 값에 Math.round를 하면 소숫점이 반올림되어 정수가 된다.
			// 거기에 p(10을 limit만큽제곱된 수)를 다시 나누면 limit만큼의 소수점 자리를 갖게 된다.
			return  Math.round( p * num ) / p;
		}
		
		
		/**
		 *  value로 대입된 수를 기준으로 제일 가까운 수를 반환한다. 2번째와 3번째 순서는 바뀌어도 상관이 없다.
		 * @param	value  비교기준이 되는 수
		 * @param	first 비교 첫번째수
		 * @param	second 비교 두번째수
		 * @return
		 */
		public static function getNearNumber( value:Number, first:Number, second:Number ):Number
		{
			return  Math.min( Math.max( value, Math.min( first, second ) ), Math.max( first, second ) );
		}
		
		
		/**
		 * 두 수의 중간값(Interpolate)에서 percent 만큼의 수를 반환
		 * @param	per
		 * @param	begin
		 * @param	end
		 * @return
		 */
		public static function getInterpolate( amount:Number, begin:Number, end:Number ):Number
		{
			return  begin + ( end - begin ) * amount;
		}
		
		
		/**
		 * 입력된 data는 max값에 대해 몇 퍼센트인지를  반환
		 * @param	data - 값
		 * @param	max - 최대값
		 * @return
		 */
		public static function getPercent( data:Number, max:Number ):Number
		{
			return  Math.floor( data / max * 100 ) / 100;
		}
		
		
		
		/**
		 * 로드 데이타 퍼센트 구하기
		 * @param	min
		 * @param	max
		 * @return
		 */
		public static function getLoadPercent( min:Number, max:Number ):Number
		{
			return  Math.floor( min / max * 100 );
		}
		
		
		/**
		 * 데이터 값으로 스트림 바 같은 크기값을 구할때 사용
		 * (현재 데이터/총데이터)*그래픽총크기값
		 * @param	currentData  현재 진행중인 데이터
		 * @param	totalData 총 데이터값
		 * @param	value 그래픽 등의 총값
		 * @return
		 */
		public static function getValueAverage( currentData:Number, totalData:Number, value:Number ):Number
		{
			return  Math.floor(( currentData / totalData ) * value );
		}
		
		
		/**
		 * frameRate 값 가져오기~
		 * @return
		 */
		public static function getFrameRate():Number
		{
			return  StageUtils.getStage().stage.frameRate;
		}
		
		
		
		/**
		 * 시간 표시 변환 메소드~
		 * @param	t
		 * @return
		 */
		public static function getProcessTime( t:int ):String
		{
			var processTime:int = t;
			var hour:int = int( processTime / 3600 );
			var minute:int = int( processTime % 3600 ) / 60;
			var second:int = int( processTime % 3600 ) % 60;
			var returnTime:String = ( minute < 10 ? "0" : "" ) + minute + ":" + ( second < 10 ? "0" : "" ) + second;
			return  returnTime;
		}
		
		/**
		 * 숫자에 0 붙이기~
		 * @param	value
		 * @return
		 */
		public static function addLeadingZero( value:Number ):String
		{
			return  ( value < 10 ) ? '0' + value : value.toString();
		}
		
		
		/**
		 * 세자리수 마다 입력된 String으로 배치 및 추가인덱스에 추가 문구 삽입
		 * @param	value
		 * @param	minLen 인덱스값을 거꾸로 삽입~
		 * @param	kDelim=","
		 * @param	fillChar="0"
		 * @example   NumberUtil.getFormat(1234567, ",", 8, "$");  // Traces $1,234,567
		 * @return
		 */
		public static function getFormat( value:Number, minLen:uint = 0, kDelim:String = ",", fillChar = "0" ):String
		{
			const remainder:Number = value % 1;
			var num:String= Math.floor( value ).toString();
			const len:uint= num.length;
			
			//minLen 값이 0과 다를때 직접 대입되는 값이 있다면 실행~
			if  ( minLen != 0 && minLen > len )
			{
				minLen-=len;
				
				const addChar:String =fillChar || '0';
				
				while  ( minLen-- )
					num=addChar + num;
			}
			
			if  ( kDelim != null && num.length > 3 )
			{
				const totalDelim:uint  = Math.floor( num.length / 3 );
				const totalRemain:uint = num.length % 3;
				const numSplit:Array= num.split( '' );
				var i:int= -1;
				
				while  ( ++i < totalDelim )
					numSplit.splice( totalRemain + ( 4 * i ), 0, kDelim );
				
				if  ( totalRemain == 0 )
					numSplit.shift();
				
				num=numSplit.join( '' );
			}
			
			if  ( remainder != 0 )
				num+=remainder.toString().substr( 1 );
			
			return  num;
		}
		
		
		/**
		 *
		 * 소수점 지우기~반올림하지 않는다.
		 * @param	n - 적용할 수치
		 * @return
		 *
		 */
		public static function getDecimalClear( n:Number ):int
		{
			var sn:int = int( n );
			return  sn;
		}
		
		
		
		/**
		 *
		 * 주어진 수치값에 0붙이기~
		 * @param	n - 0붙일 문자
		 * @param	len - 제한할 문자수
		 * @return
		 *
		 */
		public static function getAddNumToZero( n:Number, len:Number ):String
		{
			var r:String;
			
			r=String( n );
			
			while  ( r.length < len )
				r="0" + r;
			return  r;
		}
		
		
		/**
		 *  서수 만들기
		 * @param	value
		 * @return
		 * @example 
		 *    
		 *        trace(32 + NumberUtil.getOrdinalSuffix(32)); // Traces 32nd
		 *    
		 */
		public static function getOrdinalSuffix( value:int ):String
		{
			if  ( value >= 10 && value <= 20 )
				return  'th';
			
			if  ( value == 0 )
				return  '';
			
			switch  ( value % 10 )
			{
				case 3: 
					return  'rd';
				case 2: 
					return  'nd';
				case 1: 
					return  'st';
				default: 
					return  'th';
			}
		}
	
	
	}

}