org.jpedal.utils.NumberUtils Maven / Gradle / Ivy
/*
* ===========================================
* Java Pdf Extraction Decoding Access Library
* ===========================================
*
* Project Info: http://www.idrsolutions.com
* Help section for developers at http://www.idrsolutions.com/support/
*
* (C) Copyright 1997-2015 IDRsolutions and Contributors.
*
* This file is part of JPedal/JPDF2HTML5
*
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* ---------------
* NumberUtils.java
* ---------------
*/
package org.jpedal.utils;
/**
* useful static number methods
*/
public class NumberUtils {
public static final int[] powers={1,10,100,1000,10000,100000,1000000,10000000,100000000,
1000000000};
/**
* turn stream of bytes into a number
*/
public static int parseInt(int i, final int j, final byte[] bytes) {
int finalValue=0;
int power=0;
boolean isNegative=false;
i--; //decrement pointer to speed up
for(int current=j-1;current>i;current--){
if(bytes[current]=='-'){
isNegative=true;
}else{
if(bytes[current]!='0') {
finalValue += ((bytes[current]-48)*powers[power]);
}
//System.out.println(finalValue+" "+powers[power]+" "+current+" "+(char)bytes[current]+" "+bytes[current]);
power++;
}
}
if(isNegative) {
return -finalValue;
} else {
return finalValue;
}
}
public static double convertStreamFromDouble(byte[] stream, int intStart, int decStart, int intNumbers, int decNumbers) {
double dec;
double num;
double d;
double thous=0f,units=0f,tens=0f,hundreds=0f,tenths=0f,hundredths=0f, thousands=0f, tenthousands=0f,hunthousands=0f,millis=0f;
//thousands
if(intNumbers>3){
thous = getThousands(stream, intStart);
intStart++;
}
//hundreds
if(intNumbers>2){
hundreds = getHundreds(stream, intStart);
intStart++;
}
//tens
if(intNumbers>1){
tens = getTens(stream, intStart);
intStart++;
}
//units
if(intNumbers>0){
units = getUnits(stream, intStart);
}
//tenths
if(decNumbers>1){
decStart++; //move beyond.
tenths = getTenths(stream, decStart);
}
//hundredths
if(decNumbers>2){
decStart++; //move beyond.
hundredths = getHundredths(stream, decStart);
}
//thousands
if(decNumbers>3){
decStart++; //move beyond.
thousands = getThousandths(stream, decStart);
}
//tenthousands
if(decNumbers>4){
decStart++; //move beyond.
tenthousands = getTenThousandths(stream, decStart);
}
//100thousands
if(decNumbers>5){
decStart++; //move beyond.
hunthousands = getHundredThousdandths(stream, decStart);
}
if(decNumbers>6){
decStart++; //move beyond.
millis = getMillionths(stream, decStart);
}
dec=tenths+hundredths+thousands+tenthousands+hunthousands+millis;
num=thous+hundreds+tens+units;
d=num+dec;
return d;
}
/**
* turn stream of bytes into a flaot number
*/
public static float parseFloat(final int start, final int end, final byte[] stream) {
final float d;
int ptr=end;
int intStart=start;
boolean isMinus=false;
//hand optimised float code
//find decimal point
for(int j=end-1;j>start-1;j--){
if(stream[j]==46){ //'.'=46
ptr=j;
break;
}
}
int intChars=ptr;
final int decStart=ptr;
//allow for minus
if(stream[start]==43){ //'+'=43
intChars--;
intStart++;
}else if(stream[start]==45){ //'-'=45
//intChars--;
intStart++;
isMinus=true;
}
//optimisations
final int intNumbers=intChars-intStart;
final int decNumbers=end-ptr;
if(intNumbers>4){// || decNumbers>4){ //non-optimised to cover others
isMinus=false;
final int count=end-start;
final byte[] floatVal=new byte[count];
System.arraycopy(stream, start,floatVal,0,count);
//System.out.println(new String(floatVal)+"<");
d=Float.parseFloat(new String(floatVal));
}else{
d = convertFloatFromStream(stream, intStart, decStart, intNumbers, decNumbers);
}
if(isMinus) {
return -d;
} else {
return d;
}
}
public static float convertFloatFromStream(byte[] stream, int intStart, int decStart, int intNumbers, int decNumbers) {
float dec;
float num;
float d;
float thous=0f,units=0f,tens=0f,hundreds=0f,tenths=0f,hundredths=0f, thousands=0f, tenthousands=0f,hunthousands=0f,millis=0f;
//thousands
if(intNumbers>3){
thous = getThousands(stream, intStart);
intStart++;
}
//hundreds
if(intNumbers>2){
hundreds = getHundreds(stream, intStart);
intStart++;
}
//tens
if(intNumbers>1){
tens = getTens(stream, intStart);
intStart++;
}
//units
if(intNumbers>0){
units = getUnits(stream, intStart);
}
//tenths
if(decNumbers>1){
decStart++; //move beyond.
tenths = getTenths(stream, decStart);
}
//hundredths
if(decNumbers>2){
decStart++; //move beyond.
hundredths = getHundredths(stream, decStart);
}
//thousands
if(decNumbers>3){
decStart++; //move beyond.
thousands = getThousandths(stream, decStart);
}
//tenthousands
if(decNumbers>4){
decStart++; //move beyond.
tenthousands = getTenThousandths(stream, decStart);
}
//100thousands
if(decNumbers>5){
decStart++; //move beyond.
hunthousands = getHundredThousdandths(stream, decStart);
}
if(decNumbers>6){
decStart++; //move beyond.
millis = getMillionths(stream, decStart);
}
dec=tenths+hundredths+thousands+tenthousands+hunthousands+millis;
num=thous+hundreds+tens+units;
d=num+dec;
return d;
}
private static float getMillionths(final byte[] stream, final int decStart) {
float millis=0;
final int c=stream[decStart]-48;
switch(c){
case 1:
millis=0.000001f;
break;
case 2:
millis=0.000002f;
break;
case 3:
millis=0.000003f;
break;
case 4:
millis=0.000004f;
break;
case 5:
millis=0.000005f;
break;
case 6:
millis=0.000006f;
break;
case 7:
millis=0.000007f;
break;
case 8:
millis=0.000008f;
break;
case 9:
millis=0.000009f;
break;
}
return millis;
}
private static float getHundredThousdandths(final byte[] stream, final int decStart) {
float hunthousands=0;
final int c=stream[decStart]-48;
switch(c){
case 1:
hunthousands=0.00001f;
break;
case 2:
hunthousands=0.00002f;
break;
case 3:
hunthousands=0.00003f;
break;
case 4:
hunthousands=0.00004f;
break;
case 5:
hunthousands=0.00005f;
break;
case 6:
hunthousands=0.00006f;
break;
case 7:
hunthousands=0.00007f;
break;
case 8:
hunthousands=0.00008f;
break;
case 9:
hunthousands=0.00009f;
break;
}
return hunthousands;
}
private static float getTenThousandths(final byte[] stream, final int decStart) {
float tenthousands=0;
final int c=stream[decStart]-48;
switch(c){
case 1:
tenthousands=0.0001f;
break;
case 2:
tenthousands=0.0002f;
break;
case 3:
tenthousands=0.0003f;
break;
case 4:
tenthousands=0.0004f;
break;
case 5:
tenthousands=0.0005f;
break;
case 6:
tenthousands=0.0006f;
break;
case 7:
tenthousands=0.0007f;
break;
case 8:
tenthousands=0.0008f;
break;
case 9:
tenthousands=0.0009f;
break;
}
return tenthousands;
}
private static float getThousandths(final byte[] stream, final int decStart) {
float thousands=0;
final int c=stream[decStart]-48;
switch(c){
case 1:
thousands=0.001f;
break;
case 2:
thousands=0.002f;
break;
case 3:
thousands=0.003f;
break;
case 4:
thousands=0.004f;
break;
case 5:
thousands=0.005f;
break;
case 6:
thousands=0.006f;
break;
case 7:
thousands=0.007f;
break;
case 8:
thousands=0.008f;
break;
case 9:
thousands=0.009f;
break;
}
return thousands;
}
private static float getHundredths(final byte[] stream, final int decStart) {
float hundredths=0;
final int c=stream[decStart]-48;
switch(c){
case 1:
hundredths=0.01f;
break;
case 2:
hundredths=0.02f;
break;
case 3:
hundredths=0.03f;
break;
case 4:
hundredths=0.04f;
break;
case 5:
hundredths=0.05f;
break;
case 6:
hundredths=0.06f;
break;
case 7:
hundredths=0.07f;
break;
case 8:
hundredths=0.08f;
break;
case 9:
hundredths=0.09f;
break;
}
return hundredths;
}
private static float getTenths(final byte[] stream, final int decStart) {
float tenths=0;
final int c=stream[decStart]-48;
switch(c){
case 1:
tenths=0.1f;
break;
case 2:
tenths=0.2f;
break;
case 3:
tenths=0.3f;
break;
case 4:
tenths=0.4f;
break;
case 5:
tenths=0.5f;
break;
case 6:
tenths=0.6f;
break;
case 7:
tenths=0.7f;
break;
case 8:
tenths=0.8f;
break;
case 9:
tenths=0.9f;
break;
}
return tenths;
}
private static float getUnits(final byte[] stream, final int intStart) {
float units=0;
final int c=stream[intStart]-48;
switch(c){
case 1:
units=1.0f;
break;
case 2:
units=2.0f;
break;
case 3:
units=3.0f;
break;
case 4:
units=4.0f;
break;
case 5:
units=5.0f;
break;
case 6:
units=6.0f;
break;
case 7:
units=7.0f;
break;
case 8:
units=8.0f;
break;
case 9:
units=9.0f;
break;
}
return units;
}
private static float getTens(final byte[] stream, final int intStart) {
float tens=0;
final int c=stream[intStart]-48;
switch(c){
case 1:
tens=10.0f;
break;
case 2:
tens=20.0f;
break;
case 3:
tens=30.0f;
break;
case 4:
tens=40.0f;
break;
case 5:
tens=50.0f;
break;
case 6:
tens=60.0f;
break;
case 7:
tens=70.0f;
break;
case 8:
tens=80.0f;
break;
case 9:
tens=90.0f;
break;
}
return tens;
}
private static float getHundreds(final byte[] stream, final int intStart) {
float hundreds=0;
final int c=stream[intStart]-48;
switch(c){
case 1:
hundreds=100.0f;
break;
case 2:
hundreds=200.0f;
break;
case 3:
hundreds=300.0f;
break;
case 4:
hundreds=400.0f;
break;
case 5:
hundreds=500.0f;
break;
case 6:
hundreds=600.0f;
break;
case 7:
hundreds=700.0f;
break;
case 8:
hundreds=800.0f;
break;
case 9:
hundreds=900.0f;
break;
}
return hundreds;
}
private static float getThousands(final byte[] stream, final int intStart) {
float thous=0;
final int c=stream[intStart]-48;
switch(c){
case 1:
thous=1000.0f;
break;
case 2:
thous=2000.0f;
break;
case 3:
thous=3000.0f;
break;
case 4:
thous=4000.0f;
break;
case 5:
thous=5000.0f;
break;
case 6:
thous=6000.0f;
break;
case 7:
thous=7000.0f;
break;
case 8:
thous=8000.0f;
break;
case 9:
thous=9000.0f;
break;
}
return thous;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy