请高手们帮忙
我写了一个 但是转码不太成功 不知道偏差出在了哪里
function n10To64(value) { var ISNeg=false;
if(value<0)
{
value=Math.abs(value);
ISNeg=true;
}
var i64BitTable = new Array('A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/');
if(value==0)
return i64BitTable[0]+"";
var retValue="";
while(value!=0)
{
var iValue=(value&0x000000000000003F);
var temp;
temp=i64BitTable[iValue];
retValue=temp+retValue;
value = value>>6;
value=Math.abs(value);
alert(value);
}
if(ISNeg)
retValue="-"+retValue;
return retValue;
}
我写了一个 但是转码不太成功 不知道偏差出在了哪里
function n10To64(value) { var ISNeg=false;
if(value<0)
{
value=Math.abs(value);
ISNeg=true;
}
var i64BitTable = new Array('A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/');
if(value==0)
return i64BitTable[0]+"";
var retValue="";
while(value!=0)
{
var iValue=(value&0x000000000000003F);
var temp;
temp=i64BitTable[iValue];
retValue=temp+retValue;
value = value>>6;
value=Math.abs(value);
alert(value);
}
if(ISNeg)
retValue="-"+retValue;
return retValue;
}
10进制 转为 64进制 即 输入 123456 输出结果为64进制的 eJA
if (value == 0) return "A";
var sign = value < 0 ? "-" : "";
value = Math.abs(value);
var i64BitTable = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split("");
var retValue = [sign];
while (value > 0) {
retValue.unshift(i64BitTable[value & 0x3f]);
value >>= 6;
}
return retValue.join("");
}
alert(n10To64(123456));
我输入 1234567891234 return 返回 Bx+wki 但是应 转码为 R9x+wki
单精度型能精确到七位，而双精度能精确到15位。
javascript中的Number为双精度类型，只能精确到15位。
var n = 12345678901234567890 （javascript实际保存的是：12345678901234567000）var n = "1234567890123456789012345678901234567890"; // 这样以前写过delphi和c#的无限进制转换，晚上翻翻，给你转个js的。
<html>
<head>
<meta http-equiv='Content-Type' content='text/html; charset=utf-8' />
<meta name='author' content='Zswang 王集鹄 2011年1月19日'>
<title>无限进制整数计算</title>
<script>
/**
* 无限进制整数命名空间
*/
var Integer = Integer || {};
(function() {
/**
* 进制字符串
*/
var scaleChars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/";
/**
* 向前补零 "1",5 -> "00001"
* @param {String} n 整数字符串
* @param {Number} len 长度
* @return {String} 返回补零后的字符串
*/
function fullZero(n, len) {
return new Array(len - n.length + 1).join("0") + n;
}
/**
* 清理整数前面无效的零 "000000001" -> "1"
* @param {String} n 整数字符串
* @return {String} 返回格式化后的整数字符串
*/
function format(n) {
return n.replace(/^0+(.+)$/, "$1");
}
/**
* 比较两个整数的大小 "1","0" -> +1
* @param {String} a
* @param {String} b
* @return {Number} a>b返回+1,a==b返回0,a<b返回-1
*/
function compare(a, b) {
var i = Math.max(a.length, b.length), ta, tb;
a = fullZero(a, i);
b = fullZero(b, i);
for (i = 0; i < a.length; i++) {
ta = scaleChars.indexOf(a.charAt(i));
tb = scaleChars.indexOf(b.charAt(i));
if (ta < tb) return -1;
if (ta > tb) return +1;
}
return 0;
}
//console.log(compare("01", "1"));
//console.log(compare("0a1", "ab1"));
/**
* 无限进制的加法
* @param {String} a 整数1
* @param {String} b 整数2
* @param {Number} scale 进制 2-64
* @return {String} 返回两个数的和
*/
function add(a, b, scale) {
if (scale < 2 || scale > 64) return;
a = format(a);
b = format(b);
var i = Math.max(a.length, b.length), t = 0, result = [];
a = fullZero(a, i);
b = fullZero(b, i);
while (i--) {
t += scaleChars.indexOf(a.charAt(i));
t += scaleChars.indexOf(b.charAt(i));
result.unshift(scaleChars.charAt(t % scale));
t = t / scale;
}
if (t) result.unshift(scaleChars.charAt(t % scale));
return format(result.join(""));
}
//console.log(add("19", "1234", 10));
/**
* 无限位数乘法函数,单个数乘无限进制整数
* @param {String} n 整数
* @param {Number} b 单个数
* @param {Number} scale 进制 2-64
* @return {String} 返回n和b的乘积
*/
function byteMult(n, b, scale) {
//if (scale < 2 || scale > 64) return;
var result = [], t = 0, i = n.length;
while (i--) {
t = scaleChars.indexOf(n.charAt(i)) * b + t;
result.unshift(scaleChars.charAt(t % scale));
t = t / scale;
}
if (t) result.unshift(scaleChars.charAt(t % scale));
return result.join("");
}
//console.log(byteMult("555", 12, 10));
//console.log(byteMult("25", 8, 10));
/**
* 无限整数乘法
* @param {String} a 整数1
* @param {String} b 整数2
* @param {Number} scale 进制 2-64
* @return {String} 返回两个数的乘积
*/
function mult(a, b, scale) {
if (scale < 2 || scale > 64) return;
a = format(a);
b = format(b);
var t = "", result = "", i = b.length;
while (i--) {
result = add(result, byteMult(a, scaleChars.indexOf(b.charAt(i)), scale) + t, scale);
t += "0";
}
return result;
}
//console.log(mult("555", "12", 10)); // 6660
//console.log(mult("25", "8", 10)); // 200
/**
* 无限整数的次方
* @param {String} base 指数
* @param {String} exponent 幂数
* @param {Number} scale 进制 2-64
* @return {String} 返回base的exponent次方
*/
function power(base, exponent, scale) {
if (scale < 2 || scale > 64 || exponent < 0) return;
base = format(base);
var result = "1", i = exponent;
while (i--) {
result = mult(result, base, scale);
}
return result;
}
//console.log(power("2", 10, 10)); // 1024
/**
* 将一个字符转换为指定进制
* @param {String} c 单个字符
* @param {Number} from 来源进制 2-64
* @param {Number} to 目标进制 2-64
* @return {String} 返回转换后的数字
*/
function charDigit(c, from, to) {
//if (from == to || from < 2 || from > 64 || to < 2 || to > 64 || c == "0") return c;
var result = "0", t = "0";
while (compare(t, c) < 0) {
result = add(result, "1", to);
t = add(t, "1", from);
}
return result;
}
//console.log(charDigit("7", 10, 2)); // 111
/**
* 进制间的转换
* @param {String} n 整数
* @param {Number} from 来源进制 2-64
* @param {Number} to 目标进制 2-64
* @return {String} 返回转换后的数字
*/
function digit(n, from, to) {
if (from == to || from < 2 || from > 64 || to < 2 || to > 64) return n;
n = format(n);
if (n == "0") return n;
var result = "", base = "1", t = "1", m = scaleChars.charAt(from - 1), l = n.length, i;
while (compare(t, m) <= 0) {
base = add(base, "1", to);
t = add(t, "1", from);
}
for (i = 0; i < l; i++) {
result = add(result, mult(
charDigit(
n.charAt(l - i - 1), from, to
), power(base, i, to), to),
to);
}
return result;
}
//console.log(digit("1024", 10, 2)); // 10000000000
//console.log(digit("7", 10, 2)); // 111
//console.log(digit("askdjfas91231as", 64, 7)); // 43425343430315560320062336416102
//console.log(digit(digit("askdjfas91231as", 64, 7), 7, 64)); // askdjfas91231as // 公开接口
Integer.add = add;
Integer.mult = mult;
Integer.power = power;
Integer.digit = digit;
})();
</script>
</head>
<body>
<script>
var str = "1234567891234";
function n10To64(value) {
if (!value) return;
value = Integer.digit(value, 10, 64);
var a = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/";
var b = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
return value.replace(/[a-z\d+\/]/ig, function(all) {
return b.charAt(a.indexOf(all));
});
}
document.write(n10To64(str)); // R9x+wki
</script>
</body>
</html>为了coding。
/// <summary>
/// 进制字符串
/// </summary>
const string ScaleChars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; /// <summary>
/// 对齐前补
/// </summary>
/// <param name="AInteger">整数字符串</param>
/// <param name="ALength">总长度</param>
/// <returns>返回补后的整数字符串</returns>
public string IntegerFullZero(string AInteger, int ALength)
{
return string.Format("{0," + (ALength - AInteger.Length).ToString() + "}",
"").Replace(" ", "0") + AInteger;
}/// <summary>
/// 清除无效的
/// </summary>
/// <param name="AInteger">整数字符串</param>
/// <returns>返回处理后的整数字符串</returns>
public string IntegerFormat(string AInteger)
{
string Result = AInteger.ToUpper();
if (Result == string.Empty) return "0";
while (Result.IndexOf('0') == 0 && Result != "0")
{
Result = Result.Remove(0, 1); //排除整数前无效的
}
return Result;
}/// <summary>
/// 比较两个整数
/// </summary>
/// <param name="AIntegerA">整数</param>
/// <param name="AIntegerB">整数</param>
/// <returns>返回比较的值+1、、-1</returns>
public int IntegerCompare(string AIntegerA, string AIntegerB)
{
int i = Math.Max(AIntegerA.Length, AIntegerB.Length);
AIntegerA = IntegerFullZero(AIntegerA, i);
AIntegerB = IntegerFullZero(AIntegerB, i);
return string.Compare(AIntegerA, AIntegerB);
}/// <summary>
/// 无限进制的加法
/// </summary>
/// <param name="AIntegerA">整数</param>
/// <param name="AIntegerB">整数</param>
/// <param name="AScale">进制</param>
/// <returns>返回两数的和</returns>
public string IntegerAdd(string AIntegerA, string AIntegerB, byte AScale)
{
if (AScale < 2) return string.Empty;
AIntegerA = IntegerFormat(AIntegerA);
AIntegerB = IntegerFormat(AIntegerB);
int i = Math.Max(AIntegerA.Length, AIntegerB.Length);
AIntegerA = IntegerFullZero(AIntegerA, i);
AIntegerB = IntegerFullZero(AIntegerB, i);
int t = 0;
string Result = string.Empty;
for (i = i - 1; i >= 0; i--)
{
t += ScaleChars.IndexOf(AIntegerA[i]);
t += ScaleChars.IndexOf(AIntegerB[i]);
Result = ScaleChars[t % AScale] + Result;
t = t / AScale;
}
if (t != 0) Result = ScaleChars[t % AScale] + Result;
return IntegerFormat(Result);
}/// <summary>
/// 无限位数乘法函数
/// </summary>
/// <param name="AInteger">整数</param>
/// <param name="AByte">位数</param>
/// <param name="AScale">进制</param>
/// <returns>返回整数和位数的积</returns>
private string ByteMult(string AInteger, byte AByte, byte AScale)
{
string Result = string.Empty;
int t = 0;
for (int i = AInteger.Length - 1; i >= 0; i--)
{
t = ScaleChars.IndexOf(AInteger[i]) * AByte + t;
Result = ScaleChars[t % AScale] + Result;
t = t / AScale;
}
if (t != 0) Result = ScaleChars[t % AScale] + Result;
return Result;
}/// <summary>
/// 无限整数乘法
/// </summary>
/// <param name="AIntegerA">整数</param>
/// <param name="AIntegerB">整数</param>
/// <param name="AScale">进制</param>
/// <returns>返回两个整数的积</returns>
public string IntegerMult(string AIntegerA, string AIntegerB, byte AScale)
{
if (AScale < 2) return string.Empty;
AIntegerA = IntegerFormat(AIntegerA);
AIntegerB = IntegerFormat(AIntegerB);
string t = "";
string Result = string.Empty;
for (int i = AIntegerB.Length - 1; i >= 0; i--)
{
Result = IntegerAdd(Result, ByteMult(AIntegerA,
(byte)ScaleChars.IndexOf(AIntegerB[i]), AScale) + t, AScale);
t += "0";
}
return IntegerFormat(Result);
}/// <summary>
/// 无限整数的次方
/// </summary>
/// <param name="ABase">指数</param>
/// <param name="AExponent">幂数</param>
/// <param name="AScale">进制</param>
/// <returns>返回Base的Exponent次方</returns>
public string IntegerPower(string ABase, int AExponent, byte AScale)
{
if (AScale < 2) return string.Empty;
ABase = IntegerFormat(ABase);
string Result = "1";
for(int i = 0; i < AExponent; i++)
{
Result = IntegerMult(Result, ABase, AScale);
}
return Result;
}/// <summary>
/// 将一个字符转换为指定进制
/// </summary>
/// <param name="AIntegerFrom"></param>
/// <param name="AScaleFrom">来源进制</param>
/// <param name="AScaleTo">目标进制</param>
/// <returns>返回转换后的数字</returns>
private string CharDigit(char AIntegerChar, byte AScaleFrom, byte AScaleTo)
{
string Result = "0";
string t = "0";
while (IntegerCompare(t, string.Empty + AIntegerChar) < 0)
{
Result = IntegerAdd(Result, "1", AScaleTo);
t = IntegerAdd(t, "1", AScaleFrom);
}
return Result;
} /* CharDigit *//// <summary>
/// 进制间的转换
/// </summary>
/// <param name="AIntegerFrom">来源整数</param>
/// <param name="AScaleFrom">来源进制</param>
/// <param name="AScaleTo">目标进制</param>
/// <returns>返回处理后的整数字符串</returns>
public string IntegerDigit(string AIntegerFrom, byte AScaleFrom, byte AScaleTo)
{
if (AScaleFrom < 2 || AScaleTo < 2) return string.Empty; // 不处理一进制
AIntegerFrom = IntegerFormat(AIntegerFrom);
if (AScaleFrom == AScaleTo || AIntegerFrom == "0") return AIntegerFrom;
string Result = string.Empty;
string vBase = "1";
string t = "1";
while (IntegerCompare(t, string.Empty + ScaleChars[AScaleFrom - 1]) <= 0)
{
vBase = IntegerAdd(vBase, "1", AScaleTo);
t = IntegerAdd(t, "1", AScaleFrom);
}
int l = AIntegerFrom.Length;
for(int i = 0; i < l; i++)
{
Result = IntegerAdd(
Result,
IntegerMult(
CharDigit(
AIntegerFrom[l - i - 1], AScaleFrom, AScaleTo
),
IntegerPower(
vBase,
i,
AScaleTo
),
AScaleTo),
AScaleTo
);
}
return Result;
} /* IntegerDigit */private void button1_Click(object sender, EventArgs e)
{
Text = IntegerDigit("32767", 10, 16);
}
(*//
标题:无限进制处理
说明:使用于数学领域进制之间相互转换和计算
设计:Zswang
日期:2005-01-15
支持:[email protected]
//*)uses Math;const
cScaleChar: array[0..35] of Char = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';function StringToCharSet( //字符串集合
mString: string //源字符串
): TSysCharSet; //返回字符串中包含的集合
var
I: Integer;
begin
Result := [];
for I := 1 to Length(mString) do Include(Result, mString[I]);
end; { StringToCharSet }function StrLeft( //取左边的字符串
mStr: string; //原字符串
mDelimiter: string; //分隔符
mIgnoreCase: Boolean = False //是否忽略大小写
): string; //返回第一个分隔符左边的字符串
begin
if mIgnoreCase then
Result := Copy(mStr, 1, Pos(UpperCase(mDelimiter), UpperCase(mStr)) - 1)
else Result := Copy(mStr, 1, Pos(mDelimiter, mStr) - 1);
end; { StrLeft }function StrRight( //取右边的字符串
mStr: string; //原字符串
mDelimiter: string; //分隔符
mIgnoreCase: Boolean = False //是否忽略大小写
): string; //返回第一个分隔符右边的字符串
begin
if mIgnoreCase then
begin
if Pos(UpperCase(mDelimiter), UpperCase(mStr)) > 0 then
Result := Copy(mStr, Pos(UpperCase(mDelimiter), UpperCase(mStr)) +
Length(mDelimiter), MaxInt)
else Result := '';
end else
begin
if Pos(mDelimiter, mStr) > 0 then
Result := Copy(mStr, Pos(mDelimiter, mStr) + Length(mDelimiter), MaxInt)
else Result := '';
end;
end; { StrRight }function IntegerFullZero( //对齐前补0
mInteger: string; //整数字符串
mLength: Integer //总长度
): string; //返回补0后的整数字符串
begin
Result := StringOfChar('0', mLength - Length(mInteger)) + mInteger;
end; { IntegerFullZero }function IntegerCompare( //比较两个整数
mIntegerA: string; //整数1
mIntegerB: string //整数2
): Integer; //返回比较的值 +1、0、-1
var
I: Integer;
begin
I := Max(Length(mIntegerA), Length(mIntegerB)); //整数部分最大
mIntegerA := IntegerFullZero(mIntegerA, I);
mIntegerB := IntegerFullZero(mIntegerB, I);
Result := CompareText(mIntegerA, mIntegerB);
end; { IntegerCompare }function IntegerFormat( //清除无效的0
mInteger: string //整数字符串
): string; //返回处理后的整数字符串
begin
Result := UpperCase(mInteger);
if Result = '' then Result := '0';
while (Pos('0', Result) = 1) and (Result <> '0') do Delete(Result, 1, 1); //排除整数前无效的0
end; { IntegerFormat }function IntegerAdd( //无限整数加法
mIntegerA: string; //整数1
mIntegerB: string; //整数2
mScale: Byte = 10 //进制
): string; //返回两个整数的和
var
I: Integer;
T: Integer;
begin
Result := '';
if mScale < 2 then Exit;
mIntegerA := IntegerFormat(mIntegerA);
mIntegerB := IntegerFormat(mIntegerB);
if StringToCharSet(mIntegerA + mIntegerB) -
[cScaleChar[0]..cScaleChar[mScale - 1]] <> [] then Exit;
I := Max(Length(mIntegerA), Length(mIntegerB)); //整数部分最大
mIntegerA := IntegerFullZero(mIntegerA, I); //对齐前补0
mIntegerB := IntegerFullZero(mIntegerB, I); //对齐前补0
T := 0; //进位数初始
for I := I downto 1 do //从后向前扫描
begin
T := (Pos(Copy(mIntegerA, I, 1), cScaleChar) - 1) + T; //累加当前数位
T := (Pos(Copy(mIntegerB, I, 1), cScaleChar) - 1) + T; //累加当前数位
Result := cScaleChar[T mod mScale] + Result; //计算当前数位上的数字
T := T div mScale; //计算进位数
end;
if T <> 0 then Result := cScaleChar[T mod mScale] + Result; //处理进位数
while (Pos('0', Result) = 1) and (Result <> '0') do Delete(Result, 1, 1); //排除整数前无效的0
end; { IntegerAdd }function IntegerSub( //无限整数减法
mIntegerA: string; //整数1
mIntegerB: string; //整数2
mScale: Byte = 10 //进制
): string; //返回两个整数的积
var
I: Integer;
T: Integer;
begin
Result := '';
if mScale < 2 then Exit;
mIntegerA := IntegerFormat(mIntegerA);
mIntegerB := IntegerFormat(mIntegerB);
if StringToCharSet(mIntegerA + mIntegerB) -
[cScaleChar[0]..cScaleChar[mScale - 1]] <> [] then Exit;
I := Max(Length(mIntegerA), Length(mIntegerB)); //整数部分最大
mIntegerA := IntegerFullZero(mIntegerA, I); //对齐前补0
mIntegerB := IntegerFullZero(mIntegerB, I); //对齐前补0
if mIntegerA < mIntegerB then Exit;
T := 0; //进位数初始
for I := I downto 1 do //从后向前扫描
begin
T := (Pos(Copy(mIntegerA, I, 1), cScaleChar) - 1) - T; //累加当前数位
T := T - (Pos(Copy(mIntegerB, I, 1), cScaleChar) - 1); //累加当前数位
Result := cScaleChar[(T + mScale) mod mScale] + Result; //计算当前数位上的数字
if T >= 0 then T := 0 else T := 1;
end; while (Pos('0', Result) = 1) and (Result <> '0') do Delete(Result, 1, 1); //排除整数前无效的0
end; { IntegerSub }function IntegerMult( //无限整数乘法
mIntegerA: string; //整数1
mIntegerB: string; //整数2
mScale: Byte = 10 //进制
): string; //返回两个整数的积 function fMult( //无限位数乘法子函数
mInteger: string; //整数
mByte: Byte //位数
): string; //返回位数和整数的积
var
I: Integer;
T: Integer;
begin
Result := '';
T := 0;
for I := Length(mInteger) downto 1 do //从后向前扫描
begin
T := (Pos(Copy(mInteger, I, 1), cScaleChar) - 1) * mByte + T; //累加当前数位
Result := cScaleChar[T mod mScale] + Result; //计算当前数位上的数字
T := T div mScale; //计算进位数
end;
if T <> 0 then Result := cScaleChar[T mod mScale] + Result; //处理进位数
end; { fMult }var
I: Integer;
T: string;
begin
Result := '';
if mScale < 2 then Exit;
mIntegerA := IntegerFormat(mIntegerA);
mIntegerB := IntegerFormat(mIntegerB);
if StringToCharSet(mIntegerA + mIntegerB) -
[cScaleChar[0]..cScaleChar[mScale - 1]] <> [] then Exit;
T := '';
for I := Length(mIntegerB) downto 1 do
begin
Result := IntegerAdd(Result,
fMult(mIntegerA, (Pos(Copy(mIntegerB, I, 1), cScaleChar) - 1)) + T, mScale);
T := T + '0';
end;
Result := IntegerFormat(Result);
end; { InfiniteMult }function IntegerDivMod( //无限整数除法
mIntegerA: string; //整数1
mIntegerB: string; //整数2
var nDiv: string; //返回除数
var nMod: string; //返回余数
mScale: Byte = 10 //进制
): Boolean; //返回两个整数的积
var
T: string;
K: string;
begin
Result := False;
if mScale < 2 then Exit;
mIntegerA := IntegerFormat(mIntegerA);
mIntegerB := IntegerFormat(mIntegerB);
if StringToCharSet(mIntegerA + mIntegerB) -
[cScaleChar[0]..cScaleChar[mScale - 1]] <> [] then Exit;
if mIntegerB = '0' then Exit;
Result := True;
nDiv := '0';
while IntegerCompare(mIntegerA, mIntegerB) >= 0 do
begin
T := mIntegerB;
K := '1';
while IntegerCompare(mIntegerA, T + '0') >= 0 do
begin
T := T + '0';
K := K + '0';
end;
mIntegerA := IntegerSub(mIntegerA, T, mScale);
nDiv := IntegerAdd(nDiv, K, mScale);
end;
nMod := mIntegerA;
end; { IntegerDivMod }function IntegerFactorial( //无限整数的阶乘
mInteger: Integer; //整数
mScale: Byte = 10 //进制
): string; //返回整数的阶乘
var
I: Integer;
T: string;
begin
Result := '';
if mScale < 2 then Exit;
Result := '1';
T := '0';
for I := 1 to mInteger do
begin
T := IntegerAdd(T, '1', mScale);
Result := IntegerMult(Result, T, mScale);
end;
end; { InfiniteFactorial }function IntegerPower( //无限整数的次方
mBase: string; //指数
mExponent: Integer; //幂数
mScale: Byte = 10 //进制
): string; //返回Base的Exponent次方
var
I: Integer;
begin
Result := '';
if mScale < 2 then Exit;
mBase := IntegerFormat(mBase);
if StringToCharSet(mBase) -
[cScaleChar[0]..cScaleChar[mScale - 1]] <> [] then Exit;
Result := '1';
for I := 1 to mExponent do
Result := IntegerMult(Result, mBase, mScale);
end; { IntegerPower }function IntegerDigit( //进制间的转换
mIntegerFrom: string; //来源整数
mScaleFrom: Byte; //来源进制
mScaleTo: Byte //目标进制
): string; //返回处理后的整数字符串
function fIntegerDigit( //进制间的转换
mIntegerFrom: Char //来源整数
): string; //返回处理后的整数字符串
var
T: string;
begin
Result := '0';
T := '0';
while IntegerCompare(T, mIntegerFrom) < 0 do
begin
Result := IntegerAdd(Result, '1', mScaleTo);
T := IntegerAdd(T, '1', mScaleFrom);
end;
end;
var
I, L: Integer;
vBase: string;
T: string;
begin
Result := '';
if (mScaleFrom < 2) or (mScaleTo < 2) then Exit;
mIntegerFrom := IntegerFormat(mIntegerFrom);
if StringToCharSet(mIntegerFrom) -
[cScaleChar[0]..cScaleChar[mScaleFrom - 1]] <> [] then Exit;
if mScaleFrom = mScaleTo then
begin
Result := mIntegerFrom;
Exit;
end;
Result := '0';
if mIntegerFrom = '0' then Exit;
vBase := '1';
T := '1';
while IntegerCompare(T, cScaleChar[mScaleFrom - 1]) <= 0 do
begin
vBase := IntegerAdd(vBase, '1', mScaleTo);
T := IntegerAdd(T, '1', mScaleFrom);
end;
L := Length(mIntegerFrom);
for I := 1 to L do
begin
Result := IntegerAdd(
Result,
IntegerMult(
fIntegerDigit(
mIntegerFrom[L - I + 1]
),
IntegerPower(
vBase,
I - 1,
mScaleTo
),
mScaleTo)
mScaleTo
);
end;
end; { IntegerDigit }function NumberExpression(mNumber: string): string;
var
vExponent: Integer;
vBase: string;
L: Integer;
begin
Result := '';
vBase := StrLeft(mNumber, 'e', True);
vExponent := StrToIntDef(StrRight(mNumber, 'e', True), 0);
L := Length(StrRight(vBase, '.'));
vBase := StringReplace(vBase, '.', '', [rfReplaceAll]);
Result := vBase + StringOfChar('0', vExponent - L);
end; { NumberExpression }//Example
procedure TForm1.Edit1Change(Sender: TObject);
var
vDiv, vMod: string;
begin
Edit3.Text := IntegerAdd(Edit1.Text, Edit2.Text, 10);
Edit4.Text := IntegerMult(Edit1.Text, Edit2.Text, 10);
Edit5.Text := IntegerSub(Edit1.Text, Edit2.Text, 10);
IntegerDivMod(Edit1.Text, Edit2.Text, vDiv, vMod, 10);
Edit6.Text := vDiv;
Edit7.Text := vMod;
Edit8.Text := IntegerDigit(Edit1.Text, 36, 23);
Edit9.Text := IntegerDigit(Edit8.Text, 23, 36);
CheckBox2.Checked :=
IntegerCompare(IntegerAdd(IntegerMult(vDiv, Edit2.Text), vMod), Edit1.Text) = 0;
end;procedure TForm1.Button1Click(Sender: TObject);
begin
Memo1.Text := IntegerFactorial(1000, 20);
end;