33,007
社区成员
发帖
与我相关
我的任务
分享一道数学题
请问1/2 +1/3 + 1/4 + ......1/100
用数学方法该怎么解？
================================================================
CSDN 论坛助手 Ver 1.0 B0402提供下载。 改进了很多，功能完备！
★ 浏览帖子速度极快！[建议系统使用ie5.5以上]。 ★ 多种帖子实现界面。
★ 保存帖子到本地[html格式]★ 监视您关注帖子的回复更新。
★ 可以直接发贴、回复帖子★ 采用XML接口，可以一次性显示4页帖子,同时支持自定义每次显示帖子数量。可以浏览历史记录！
★ 支持在线检测程序升级情况，可及时获得程序更新的信息。
★★ 签名 ●
可以在您的每个帖子的后面自动加上一个自己设计的签名哟。
Http://www.ChinaOK.net/csdn/csdn.zip
Http://www.ChinaOK.net/csdn/csdn.rar
Http://www.ChinaOK.net/csdn/csdn.exe [自解压]
用数学方法该怎么解？
================================================================
CSDN 论坛助手 Ver 1.0 B0402提供下载。 改进了很多，功能完备！
★ 浏览帖子速度极快！[建议系统使用ie5.5以上]。 ★ 多种帖子实现界面。
★ 保存帖子到本地[html格式]★ 监视您关注帖子的回复更新。
★ 可以直接发贴、回复帖子★ 采用XML接口，可以一次性显示4页帖子,同时支持自定义每次显示帖子数量。可以浏览历史记录！
★ 支持在线检测程序升级情况，可及时获得程序更新的信息。
★★ 签名 ●
可以在您的每个帖子的后面自动加上一个自己设计的签名哟。
Http://www.ChinaOK.net/csdn/csdn.zip
Http://www.ChinaOK.net/csdn/csdn.rar
Http://www.ChinaOK.net/csdn/csdn.exe [自解压]
...全文
请发表友善的回复…
发表回复
zzwu 2002-10-20
- 打赏
- 举报
不知此问题的非近似值求解有何价值? (理论上或实际应用)
zjhangtian 2002-10-20
- 打赏
- 举报
是用手算还是编程算？
microblue 2002-10-19
- 打赏
- 举报
经计算:
H(100) = 1 + 1/2 + 1/3 + 1/4 + ... 1/100
= 14466636279520351160221518043104131447711 / 2788815009188499086581352357412492142272
= 5.18737751763962026080511767565825315790897212670845165317653395658721955753255...
源程序如下:
// h100.cs: Microblue (C) Sat 2002.10.19
// complier: csc h100.cs BigInteger.cs
// BigInteger.cs download from: http://www.codeproject.com/csharp/BigInteger.asp
using System;
namespace Microblue.Other.H
{
class H
{
static void Main(string [] args)
{
try
{
int n = 100;
if (args.Length > 0) n = Convert.ToInt32(args[0]);
Console.WriteLine("H(n) = 1 + 1/2 + 1/3 + 1/4 + ... 1/n, n = {0}", n);
Rational a = new Rational(1);
for (int i = 2; i <= n; i++)
{
a += new Rational(1, i);
Console.WriteLine("{0,3} {1}", i, a);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
class Rational
{
BigInteger p, q;
public Rational() : this(0, 1)
{
}
public Rational(BigInteger p) : this(p, 1)
{
}
public Rational(BigInteger p, BigInteger q)
{
this.p = p;
this.q = q;
}
public static Rational operator + (Rational x, Rational y)
{
Rational r = new Rational(x.p, x.q);
if (y.p == 0) return r;
if (r.p == 0) {
r.p = y.p;
r.q = y.q;
return r;
}
BigInteger u1, u2, v1, v2, w1, w2, d1, d2, t;
u1 = r.p;
u2 = r.q;
v1 = y.p;
v2 = y.q;
d1 = u2.gcd(v2);
if (d1 == 1)
{
w1 = u1 * v2 + u2 * v1;
w2 = u2 * v2;
}
else
{
t = (v2 / d1) * u1 + (u2 / d1) * v1;
d2 = t.gcd(d1);
w1 = t / d2;
w2 = (u2 / d1) * (v2 / d2);
}
r.p = w1;
r.q = w2;
return r;
}
public override string ToString()
{
return string.Format("{0} / {1}", p, q);
}
}
}
H(100) = 1 + 1/2 + 1/3 + 1/4 + ... 1/100
= 14466636279520351160221518043104131447711 / 2788815009188499086581352357412492142272
= 5.18737751763962026080511767565825315790897212670845165317653395658721955753255...
源程序如下:
// h100.cs: Microblue (C) Sat 2002.10.19
// complier: csc h100.cs BigInteger.cs
// BigInteger.cs download from: http://www.codeproject.com/csharp/BigInteger.asp
using System;
namespace Microblue.Other.H
{
class H
{
static void Main(string [] args)
{
try
{
int n = 100;
if (args.Length > 0) n = Convert.ToInt32(args[0]);
Console.WriteLine("H(n) = 1 + 1/2 + 1/3 + 1/4 + ... 1/n, n = {0}", n);
Rational a = new Rational(1);
for (int i = 2; i <= n; i++)
{
a += new Rational(1, i);
Console.WriteLine("{0,3} {1}", i, a);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
class Rational
{
BigInteger p, q;
public Rational() : this(0, 1)
{
}
public Rational(BigInteger p) : this(p, 1)
{
}
public Rational(BigInteger p, BigInteger q)
{
this.p = p;
this.q = q;
}
public static Rational operator + (Rational x, Rational y)
{
Rational r = new Rational(x.p, x.q);
if (y.p == 0) return r;
if (r.p == 0) {
r.p = y.p;
r.q = y.q;
return r;
}
BigInteger u1, u2, v1, v2, w1, w2, d1, d2, t;
u1 = r.p;
u2 = r.q;
v1 = y.p;
v2 = y.q;
d1 = u2.gcd(v2);
if (d1 == 1)
{
w1 = u1 * v2 + u2 * v1;
w2 = u2 * v2;
}
else
{
t = (v2 / d1) * u1 + (u2 / d1) * v1;
d2 = t.gcd(d1);
w1 = t / d2;
w2 = (u2 / d1) * (v2 / d2);
}
r.p = w1;
r.q = w2;
return r;
}
public override string ToString()
{
return string.Format("{0} / {1}", p, q);
}
}
}
microblue 2002-10-16
- 打赏
- 举报
调和数 H1(n) = 1 + 1/2 + 1/3 + ... + 1/n
可用以下近似公式计算:
H2(n) = ln(n)+r+1/(2n)-1/(12n^2)+1/(120n^4)-1/(252n^6)+1/(240n^8)-1/(132n^10)+...
公式中 r = 0.57721566490153286060651209... 是欧拉常数。
我写了一个 C# 程序用 double 类型计算 H1(n) 和 H2(n)。当 n 值较小时，H1(n) 较精确，而当 n 值较大时，H2(n) 较精确。
当 n 值非常大时，H1(n) 的计算速度较慢，且由于截断误差，其值也不很精确。而 H2(n) 的计算速度跟 n 值无关。
如果楼主是要计算调和数的近似值，用 H2(n) 这个近似公式就可以了。如果需要精确值，就必须使用有理算术。
计算调和数的 C# 程序:
using System;
namespace Microblue.Other.Hn
{
class Hn
{
const double r = 0.57721566490153286060651209;
static void Main()
{
try
{
Console.WriteLine("H1(n) = 1 + 1/2 + 1/3 + ... + 1/n (r = {0})", r);
Console.WriteLine("H2(n) = ln(n)+r+1/(2n)-1/(12n^2)+1/(120n^4)-1/(252n^6)+1/(240n^8)-1/(132n^10)+...");
Console.WriteLine("------------n -------------H1(n) -------------H2(n)");
int i, b;
int [] a = new int [29];
for (i = 0; i < 20; i++) a[i] = i + 1;
for (b = 10; i < 28; b *= 10, i++) a[i] = b * 10;
a[i] = b * 2;
foreach (int n in a)
Console.WriteLine("{0,13:N0} {1,18:F15} {2,18:F15}", n, H1(n), H2(n));
Console.WriteLine("------------- ------------------ ------------------");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
static double H1(int x)
{
double z = 1.0;
for (int i = 2; i <= x; i++) z += 1.0 / i;
return z;
}
static double H2(int x)
{
double y = x * x;
double w = y;
double z = r;
z += Math.Log(x);
z += 1.0 / 2 / x;
z -= 1.0 / 12 / w;
z += 1.0 / 120 / (w *= y);
z -= 1.0 / 252 / (w *= y);
z += 1.0 / 240 / (w *= y);
z -= 1.0 / 132 / (w *= y);
return z;
}
}
}
运行结果如下:
H1(n) = 1 + 1/2 + 1/3 + ... + 1/n (r = 0.577215664901533)
H2(n) = ln(n)+r+1/(2n)-1/(12n^2)+1/(120n^4)-1/(252n^6)+1/(240n^8)-1/(132n^10)+...
------------n -------------H1(n) -------------H2(n)
1 1.000000000000000 0.994838320024188
2 1.500000000000000 1.499997219334130
3 1.833333333333330 1.833333304984080
4 2.083333333333330 2.083333332312900
5 2.283333333333330 2.283333333258290
6 2.450000000000000 2.449999999991240
7 2.592857142857140 2.592857142855730
8 2.717857142857140 2.717857142856850
9 2.828968253968250 2.828968253968180
10 2.928968253968250 2.928968253968230
11 3.019877344877340 3.019877344877340
12 3.103210678210680 3.103210678210680
13 3.180133755133760 3.180133755133750
14 3.251562326562330 3.251562326562330
15 3.318228993228990 3.318228993228990
16 3.380728993228990 3.380728993228990
17 3.439552522640760 3.439552522640760
18 3.495108078196310 3.495108078196310
19 3.547739657143680 3.547739657143680
20 3.597739657143680 3.597739657143680
100 5.187377517639620 5.187377517639620
1,000 7.485470860550340 7.485470860550340
10,000 9.787606036044350 9.787606036044380
100,000 12.090146129863300 12.090146129812700
1,000,000 14.392726722865000 14.392726722980400
10,000,000 16.695311365857300 16.695311365558400
100,000,000 18.997896413852600 18.997896413809500
1,000,000,000 21.300481502348600 21.300481502404000
2,000,000,000 21.993628682662800 21.993628682708300
------------- ------------------ ------------------
可用以下近似公式计算:
H2(n) = ln(n)+r+1/(2n)-1/(12n^2)+1/(120n^4)-1/(252n^6)+1/(240n^8)-1/(132n^10)+...
公式中 r = 0.57721566490153286060651209... 是欧拉常数。
我写了一个 C# 程序用 double 类型计算 H1(n) 和 H2(n)。当 n 值较小时，H1(n) 较精确，而当 n 值较大时，H2(n) 较精确。
当 n 值非常大时，H1(n) 的计算速度较慢，且由于截断误差，其值也不很精确。而 H2(n) 的计算速度跟 n 值无关。
如果楼主是要计算调和数的近似值，用 H2(n) 这个近似公式就可以了。如果需要精确值，就必须使用有理算术。
计算调和数的 C# 程序:
using System;
namespace Microblue.Other.Hn
{
class Hn
{
const double r = 0.57721566490153286060651209;
static void Main()
{
try
{
Console.WriteLine("H1(n) = 1 + 1/2 + 1/3 + ... + 1/n (r = {0})", r);
Console.WriteLine("H2(n) = ln(n)+r+1/(2n)-1/(12n^2)+1/(120n^4)-1/(252n^6)+1/(240n^8)-1/(132n^10)+...");
Console.WriteLine("------------n -------------H1(n) -------------H2(n)");
int i, b;
int [] a = new int [29];
for (i = 0; i < 20; i++) a[i] = i + 1;
for (b = 10; i < 28; b *= 10, i++) a[i] = b * 10;
a[i] = b * 2;
foreach (int n in a)
Console.WriteLine("{0,13:N0} {1,18:F15} {2,18:F15}", n, H1(n), H2(n));
Console.WriteLine("------------- ------------------ ------------------");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
static double H1(int x)
{
double z = 1.0;
for (int i = 2; i <= x; i++) z += 1.0 / i;
return z;
}
static double H2(int x)
{
double y = x * x;
double w = y;
double z = r;
z += Math.Log(x);
z += 1.0 / 2 / x;
z -= 1.0 / 12 / w;
z += 1.0 / 120 / (w *= y);
z -= 1.0 / 252 / (w *= y);
z += 1.0 / 240 / (w *= y);
z -= 1.0 / 132 / (w *= y);
return z;
}
}
}
运行结果如下:
H1(n) = 1 + 1/2 + 1/3 + ... + 1/n (r = 0.577215664901533)
H2(n) = ln(n)+r+1/(2n)-1/(12n^2)+1/(120n^4)-1/(252n^6)+1/(240n^8)-1/(132n^10)+...
------------n -------------H1(n) -------------H2(n)
1 1.000000000000000 0.994838320024188
2 1.500000000000000 1.499997219334130
3 1.833333333333330 1.833333304984080
4 2.083333333333330 2.083333332312900
5 2.283333333333330 2.283333333258290
6 2.450000000000000 2.449999999991240
7 2.592857142857140 2.592857142855730
8 2.717857142857140 2.717857142856850
9 2.828968253968250 2.828968253968180
10 2.928968253968250 2.928968253968230
11 3.019877344877340 3.019877344877340
12 3.103210678210680 3.103210678210680
13 3.180133755133760 3.180133755133750
14 3.251562326562330 3.251562326562330
15 3.318228993228990 3.318228993228990
16 3.380728993228990 3.380728993228990
17 3.439552522640760 3.439552522640760
18 3.495108078196310 3.495108078196310
19 3.547739657143680 3.547739657143680
20 3.597739657143680 3.597739657143680
100 5.187377517639620 5.187377517639620
1,000 7.485470860550340 7.485470860550340
10,000 9.787606036044350 9.787606036044380
100,000 12.090146129863300 12.090146129812700
1,000,000 14.392726722865000 14.392726722980400
10,000,000 16.695311365857300 16.695311365558400
100,000,000 18.997896413852600 18.997896413809500
1,000,000,000 21.300481502348600 21.300481502404000
2,000,000,000 21.993628682662800 21.993628682708300
------------- ------------------ ------------------
microblue 2002-10-16
- 打赏
- 举报
这里是上面的 C# 程序的部分运行结果:
H(n) = 1 + 1/2 + 1/3 + 1/4 + ... 1/n, n = 100
----> 2 3/2
(p/q) 1.5
(decimal) 1.5
(double) 1.5
----> 3 11/6
(p/q) 1.8333333333333333333333333333
(decimal) 1.8333333333333333333333333333
(double) 1.83333333333333
----> 4 25/12
(p/q) 2.0833333333333333333333333333
(decimal) 2.0833333333333333333333333333
(double) 2.08333333333333
----> 5 137/60
(p/q) 2.2833333333333333333333333333
(decimal) 2.2833333333333333333333333333
(double) 2.28333333333333
----> 6 49/20
(p/q) 2.45
(decimal) 2.45
(double) 2.45
----> 7 363/140
(p/q) 2.5928571428571428571428571429
(decimal) 2.5928571428571428571428571429
(double) 2.59285714285714
----> 8 761/280
(p/q) 2.7178571428571428571428571429
(decimal) 2.7178571428571428571428571429
(double) 2.71785714285714
----> 9 7129/2520
(p/q) 2.828968253968253968253968254
(decimal) 2.828968253968253968253968254
(double) 2.82896825396825
----> 10 7381/2520
(p/q) 2.928968253968253968253968254
(decimal) 2.928968253968253968253968254
(double) 2.92896825396825
----> 11 83711/27720
(p/q) 3.0198773448773448773448773449
(decimal) 3.0198773448773448773448773449
(double) 3.01987734487734
----> 12 86021/27720
(p/q) 3.1032106782106782106782106782
(decimal) 3.1032106782106782106782106782
(double) 3.10321067821068
----> 13 1145993/360360
(p/q) 3.1801337551337551337551337551
(decimal) 3.1801337551337551337551337551
(double) 3.18013375513376
----> 14 1171733/360360
(p/q) 3.2515623265623265623265623266
(decimal) 3.2515623265623265623265623265
(double) 3.25156232656233
----> 15 1195757/360360
(p/q) 3.3182289932289932289932289932
(decimal) 3.3182289932289932289932289932
(double) 3.31822899322899
----> 16 2436559/720720
(p/q) 3.3807289932289932289932289932
(decimal) 3.3807289932289932289932289932
(double) 3.38072899322899
----> 17 42142223/12252240
(p/q) 3.4395525226407579348755819344
(decimal) 3.4395525226407579348755819344
(double) 3.43955252264076
----> 18 14274301/4084080
(p/q) 3.49510807819631349043113749
(decimal) 3.49510807819631349043113749
(double) 3.49510807819631
----> 19 275295799/77597520
(p/q) 3.5477396571436819114837690689
(decimal) 3.5477396571436819114837690689
(double) 3.54773965714368
----> 20 55835135/15519504
(p/q) 3.5977396571436819114837690689
(decimal) 3.5977396571436819114837690689
(double) 3.59773965714368
...
----> 61 925372872575832277072279171/197044480683803711251893600
(p/q) 4.6962638555746886368609779595
(decimal) 4.6962638555746886368609779592
(double) 4.69626385557469
----> 62 928551009361054917576341971/197044480683803711251893600
(p/q) 4.7123928878327531529900102175
(decimal) 4.7123928878327531529900102173
(double) 4.71239288783275
----> 63 310559566510213034489743057/65681493561267903750631200
(p/q) 4.7282659037057690260058832334
(decimal) 4.7282659037057690260058832332
(double) 4.72826590370577
----> 64 623171679694215690971693339/131362987122535807501262400
(p/q) 4.7438909037057690260058832334
(decimal) 4.7438909037057690260058832332
(double) 4.74389090370577
----> 65 625192648726870088010174299/131362987122535807501262400
(p/q) 4.7592755190903844106212678488
(decimal) 4.7592755190903844106212678486
(double) 4.75927551909038
----> 66 209060999005535159677640233/43787662374178602500420800
(p/q) 4.7744270342418995621364193639
(decimal) 4.7744270342418995621364193638
(double) 4.7744270342419
----> 67 14050874595745034300902316411/2933773379069966367528193600
(p/q) 4.7893524073762279203453745878
(decimal) 4.7893524073762279203453745877
(double) 4.78935240737623
----> 68 14094018321907827923954201611/2933773379069966367528193600
(p/q) 4.8040582897291690968159628231
(decimal) 4.804058289729169096815962823
(double) 4.80405828972917
----> 69 42409610330030873613929048033/8801320137209899102584580800
(p/q) 4.8185510433523575026130642724
(decimal) 4.8185510433523575026130642723
(double) 4.81855104335236
----> 70 42535343474848157886823113473/8801320137209899102584580800
(p/q) 4.8328367576380717883273499867
(decimal) 4.8328367576380717883273499866
(double) 4.83283675763807
值对于 Decimal 太大或太小。
H(n) = 1 + 1/2 + 1/3 + 1/4 + ... 1/n, n = 100
----> 2 3/2
(p/q) 1.5
(decimal) 1.5
(double) 1.5
----> 3 11/6
(p/q) 1.8333333333333333333333333333
(decimal) 1.8333333333333333333333333333
(double) 1.83333333333333
----> 4 25/12
(p/q) 2.0833333333333333333333333333
(decimal) 2.0833333333333333333333333333
(double) 2.08333333333333
----> 5 137/60
(p/q) 2.2833333333333333333333333333
(decimal) 2.2833333333333333333333333333
(double) 2.28333333333333
----> 6 49/20
(p/q) 2.45
(decimal) 2.45
(double) 2.45
----> 7 363/140
(p/q) 2.5928571428571428571428571429
(decimal) 2.5928571428571428571428571429
(double) 2.59285714285714
----> 8 761/280
(p/q) 2.7178571428571428571428571429
(decimal) 2.7178571428571428571428571429
(double) 2.71785714285714
----> 9 7129/2520
(p/q) 2.828968253968253968253968254
(decimal) 2.828968253968253968253968254
(double) 2.82896825396825
----> 10 7381/2520
(p/q) 2.928968253968253968253968254
(decimal) 2.928968253968253968253968254
(double) 2.92896825396825
----> 11 83711/27720
(p/q) 3.0198773448773448773448773449
(decimal) 3.0198773448773448773448773449
(double) 3.01987734487734
----> 12 86021/27720
(p/q) 3.1032106782106782106782106782
(decimal) 3.1032106782106782106782106782
(double) 3.10321067821068
----> 13 1145993/360360
(p/q) 3.1801337551337551337551337551
(decimal) 3.1801337551337551337551337551
(double) 3.18013375513376
----> 14 1171733/360360
(p/q) 3.2515623265623265623265623266
(decimal) 3.2515623265623265623265623265
(double) 3.25156232656233
----> 15 1195757/360360
(p/q) 3.3182289932289932289932289932
(decimal) 3.3182289932289932289932289932
(double) 3.31822899322899
----> 16 2436559/720720
(p/q) 3.3807289932289932289932289932
(decimal) 3.3807289932289932289932289932
(double) 3.38072899322899
----> 17 42142223/12252240
(p/q) 3.4395525226407579348755819344
(decimal) 3.4395525226407579348755819344
(double) 3.43955252264076
----> 18 14274301/4084080
(p/q) 3.49510807819631349043113749
(decimal) 3.49510807819631349043113749
(double) 3.49510807819631
----> 19 275295799/77597520
(p/q) 3.5477396571436819114837690689
(decimal) 3.5477396571436819114837690689
(double) 3.54773965714368
----> 20 55835135/15519504
(p/q) 3.5977396571436819114837690689
(decimal) 3.5977396571436819114837690689
(double) 3.59773965714368
...
----> 61 925372872575832277072279171/197044480683803711251893600
(p/q) 4.6962638555746886368609779595
(decimal) 4.6962638555746886368609779592
(double) 4.69626385557469
----> 62 928551009361054917576341971/197044480683803711251893600
(p/q) 4.7123928878327531529900102175
(decimal) 4.7123928878327531529900102173
(double) 4.71239288783275
----> 63 310559566510213034489743057/65681493561267903750631200
(p/q) 4.7282659037057690260058832334
(decimal) 4.7282659037057690260058832332
(double) 4.72826590370577
----> 64 623171679694215690971693339/131362987122535807501262400
(p/q) 4.7438909037057690260058832334
(decimal) 4.7438909037057690260058832332
(double) 4.74389090370577
----> 65 625192648726870088010174299/131362987122535807501262400
(p/q) 4.7592755190903844106212678488
(decimal) 4.7592755190903844106212678486
(double) 4.75927551909038
----> 66 209060999005535159677640233/43787662374178602500420800
(p/q) 4.7744270342418995621364193639
(decimal) 4.7744270342418995621364193638
(double) 4.7744270342419
----> 67 14050874595745034300902316411/2933773379069966367528193600
(p/q) 4.7893524073762279203453745878
(decimal) 4.7893524073762279203453745877
(double) 4.78935240737623
----> 68 14094018321907827923954201611/2933773379069966367528193600
(p/q) 4.8040582897291690968159628231
(decimal) 4.804058289729169096815962823
(double) 4.80405828972917
----> 69 42409610330030873613929048033/8801320137209899102584580800
(p/q) 4.8185510433523575026130642724
(decimal) 4.8185510433523575026130642723
(double) 4.81855104335236
----> 70 42535343474848157886823113473/8801320137209899102584580800
(p/q) 4.8328367576380717883273499867
(decimal) 4.8328367576380717883273499866
(double) 4.83283675763807
值对于 Decimal 太大或太小。
djniulihao 2002-10-16
- 打赏
- 举报
gz.wuyi8808(空军
shiwei1109 2002-10-16
- 打赏
- 举报
极限！！！！！
microblue 2002-10-16
- 打赏
- 举报
using System;
namespace Microblue.Other.H
{
class Rational
{
decimal p, q;
public Rational() : this(0, 1)
{
}
public Rational(decimal p) : this(p, 1)
{
}
public Rational(decimal p, decimal q)
{
this.p = p;
this.q = q;
}
public static Rational operator + (Rational x, Rational y)
{
Rational r = new Rational(x.p, x.q);
if (y.p == 0) return r;
if (r.p == 0) {
r.p = y.p;
r.q = y.q;
return r;
}
decimal u1, u2, v1, v2, w1, w2, d1, d2, t;
u1 = r.p;
u2 = r.q;
v1 = y.p;
v2 = y.q;
d1 = Gcd(u2, v2);
if (d1 == 1)
{
w1 = u1 * v2 + u2 * v1;
w2 = u2 * v2;
}
else
{
t = (v2 / d1) * u1 + (u2 / d1) * v1;
d2 = Gcd(t, d1);
w1 = t / d2;
w2 = (u2 / d1) * (v2 /d2);
}
r.p = w1;
r.q = w2;
return r;
}
public override string ToString()
{
return string.Format("{0}/{1}", p, q);
}
public static explicit operator decimal (Rational x)
{
return x.p / x.q;
}
static decimal Gcd(decimal p, decimal q)
{
if (p == 0 || q == 0) return p + q;
decimal r = p % q;
while (r != 0)
{
p = q;
q = r;
r = p % q;
}
return q;
}
}
class H
{
static void Main(string [] args)
{
try
{
int n = 10;
if (args.Length > 0) n = Convert.ToInt32(args[0]);
Console.WriteLine("H(n) = 1 + 1/2 + 1/3 + 1/4 + ... 1/n, n = {0}", n);
Rational a = new Rational(1);
decimal aa = 1;
double dd = 1.0;
for (int i = 2; i <= n; i++)
{
Rational b = new Rational(1, i);
a += b;
aa += 1m / i;
dd += 1.0 / i;
Console.WriteLine("----> {0,3} {1}", i, a);
Console.WriteLine("(p/q) {0}", (decimal)a);
Console.WriteLine("(decimal) {0}", aa);
Console.WriteLine("(double) {0}", dd);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
}
namespace Microblue.Other.H
{
class Rational
{
decimal p, q;
public Rational() : this(0, 1)
{
}
public Rational(decimal p) : this(p, 1)
{
}
public Rational(decimal p, decimal q)
{
this.p = p;
this.q = q;
}
public static Rational operator + (Rational x, Rational y)
{
Rational r = new Rational(x.p, x.q);
if (y.p == 0) return r;
if (r.p == 0) {
r.p = y.p;
r.q = y.q;
return r;
}
decimal u1, u2, v1, v2, w1, w2, d1, d2, t;
u1 = r.p;
u2 = r.q;
v1 = y.p;
v2 = y.q;
d1 = Gcd(u2, v2);
if (d1 == 1)
{
w1 = u1 * v2 + u2 * v1;
w2 = u2 * v2;
}
else
{
t = (v2 / d1) * u1 + (u2 / d1) * v1;
d2 = Gcd(t, d1);
w1 = t / d2;
w2 = (u2 / d1) * (v2 /d2);
}
r.p = w1;
r.q = w2;
return r;
}
public override string ToString()
{
return string.Format("{0}/{1}", p, q);
}
public static explicit operator decimal (Rational x)
{
return x.p / x.q;
}
static decimal Gcd(decimal p, decimal q)
{
if (p == 0 || q == 0) return p + q;
decimal r = p % q;
while (r != 0)
{
p = q;
q = r;
r = p % q;
}
return q;
}
}
class H
{
static void Main(string [] args)
{
try
{
int n = 10;
if (args.Length > 0) n = Convert.ToInt32(args[0]);
Console.WriteLine("H(n) = 1 + 1/2 + 1/3 + 1/4 + ... 1/n, n = {0}", n);
Rational a = new Rational(1);
decimal aa = 1;
double dd = 1.0;
for (int i = 2; i <= n; i++)
{
Rational b = new Rational(1, i);
a += b;
aa += 1m / i;
dd += 1.0 / i;
Console.WriteLine("----> {0,3} {1}", i, a);
Console.WriteLine("(p/q) {0}", (decimal)a);
Console.WriteLine("(decimal) {0}", aa);
Console.WriteLine("(double) {0}", dd);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
}
microblue 2002-10-16
- 打赏
- 举报
调和数 H(n) = H(n) = 1 + 1/2 + 1/3 + 1/4 + ... 1/n, n = 100，比楼主的数大1。
在D.E.Knuth的《计算机程序设计艺术》第1卷中有论述调和数，并给出了一个近似公式，还给出了前30个调和数的准确值。
我用 C# 程序计算出前 70 个调和数的准确值，并发现如果用 C# 的 decimal 类型直接计算调和数，至少前 70 个调和数可以精确计算到小数点后 25 位。
C# 中 decimal 类型可以表示 28 位十进制数。如果要计算 H(100)，正如 wuyi8808(空军)所指出的，需要能够表示 41 位十进制数。这可以使用多精度的整数运算库实现。
在D.E.Knuth的《计算机程序设计艺术》第1卷中有论述调和数，并给出了一个近似公式，还给出了前30个调和数的准确值。
我用 C# 程序计算出前 70 个调和数的准确值，并发现如果用 C# 的 decimal 类型直接计算调和数，至少前 70 个调和数可以精确计算到小数点后 25 位。
C# 中 decimal 类型可以表示 28 位十进制数。如果要计算 H(100)，正如 wuyi8808(空军)所指出的，需要能够表示 41 位十进制数。这可以使用多精度的整数运算库实现。
microblue 2002-10-15
- 打赏
- 举报
gz
FishCrazy 2002-10-15
- 打赏
- 举报
递归！递归！
KingPower410 2002-10-15
- 打赏
- 举报
main()
{
float sum=0.0;
int n=100;
for(n=2;n<=100;n++)
sum=sum+1.0/n;
print("sum is %f.",sum);
}
{
float sum=0.0;
int n=100;
for(n=2;n<=100;n++)
sum=sum+1.0/n;
print("sum is %f.",sum);
}
wuyi8808 2002-10-15
- 打赏
- 举报
实际上，就是通分的话，也用不着计算100的阶乘。
注意到100以内的素数只有以下25个：
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97
并注意到 2^6=64, 3^4=81, 5^2=25, 7^2=49，而其余素数的平方都超过100了，所以通分后公分母不会超过下面诸数的乘积：
2^6, 3^4, 5^2, 7^2, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97
我算了一下，这个乘积约等于6.97204e+40。所以只要想办法能表示41位的十进制整数，就可以精确地算出
1/2 + 1/3 + 1/4 + ... + 1/100。
注意到100以内的素数只有以下25个：
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97
并注意到 2^6=64, 3^4=81, 5^2=25, 7^2=49，而其余素数的平方都超过100了，所以通分后公分母不会超过下面诸数的乘积：
2^6, 3^4, 5^2, 7^2, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97
我算了一下，这个乘积约等于6.97204e+40。所以只要想办法能表示41位的十进制整数，就可以精确地算出
1/2 + 1/3 + 1/4 + ... + 1/100。
wuyi8808 2002-10-15
- 打赏
- 举报
#include <stdio.h>
typedef unsigned long ulong;
struct yls_t { long n; ulong p, q; };
ulong gcd(ulong p, ulong q)
{
if (p == 0 || q == 0) return (p + q);
ulong r = p % q;
while (r != 0) { p = q; q = r; r = p % q; }
return q;
}
void add(yls_t * x, const yls_t * y)
{
x->n += y->n;
if (y->p == 0) return;
if (x->p == 0) { x->p = y->p; x->q = y->q; return; }
ulong u1, u2, v1, v2, w1, w2, d1, d2, t;
u1 = x->p; u2 = x->q;
v1 = y->p; v2 = y->q;
d1 = gcd(u2, v2);
if (d1 == 1) { w1 = u1 * v2 + u2 * v1; w2 = u2 * v2; }
else {
t = (v2 / d1) * u1 + (u2 / d1) * v1;
d2 = gcd(t, d1);
w1 = t / d2; w2 = (u2 / d1) * (v2 /d2);
}
if (w1 >= w2) x->n += (w1 / w2);
x->p = w1 % w2;
x->q = w2;
}
int main()
{
int n;
yls_t a, b;
a.n = 0; a.p = 0; a.q = 1;
fprintf(stderr, "Calculate Sn = 1/2 + 1/3 + 1/4 + ... 1/n, please input n: ");
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
b.n = 0; b.p = 1; b.q = i;
add(&a, &b);
printf("S%-4d: %11ld %10lu/%lu\n", i, a.n, a.p, a.q);
}
return 0;
}
运行结果为：
Calculate Sn = 1/2 + 1/3 + 1/4 + ... 1/n, please input n: 24
S2 : 0 1/2
S3 : 0 5/6
S4 : 1 1/12
S5 : 1 17/60
S6 : 1 9/20
S7 : 1 83/140
S8 : 1 201/280
S9 : 1 2089/2520
S10 : 1 2341/2520
S11 : 2 551/27720
S12 : 2 2861/27720
S13 : 2 64913/360360
S14 : 2 90653/360360
S15 : 2 114677/360360
S16 : 2 274399/720720
S17 : 2 5385503/12252240
S18 : 2 2022061/4084080
S19 : 2 42503239/77597520
S20 : 2 9276623/15519504
S21 : 2 3338549/5173168
S22 : 2 3573693/5173168
S23 : 2 87368107/118982864
S24 : 2 276977179/356948592
我用的是Turbo C编译器，unsigned long int 是32位的，最大只能表示到 4,294,967,295，再大就溢出了，所以我只能计算到S24。谁有64位的long int的编译器，可以看一下能计算到多大的Sn。
typedef unsigned long ulong;
struct yls_t { long n; ulong p, q; };
ulong gcd(ulong p, ulong q)
{
if (p == 0 || q == 0) return (p + q);
ulong r = p % q;
while (r != 0) { p = q; q = r; r = p % q; }
return q;
}
void add(yls_t * x, const yls_t * y)
{
x->n += y->n;
if (y->p == 0) return;
if (x->p == 0) { x->p = y->p; x->q = y->q; return; }
ulong u1, u2, v1, v2, w1, w2, d1, d2, t;
u1 = x->p; u2 = x->q;
v1 = y->p; v2 = y->q;
d1 = gcd(u2, v2);
if (d1 == 1) { w1 = u1 * v2 + u2 * v1; w2 = u2 * v2; }
else {
t = (v2 / d1) * u1 + (u2 / d1) * v1;
d2 = gcd(t, d1);
w1 = t / d2; w2 = (u2 / d1) * (v2 /d2);
}
if (w1 >= w2) x->n += (w1 / w2);
x->p = w1 % w2;
x->q = w2;
}
int main()
{
int n;
yls_t a, b;
a.n = 0; a.p = 0; a.q = 1;
fprintf(stderr, "Calculate Sn = 1/2 + 1/3 + 1/4 + ... 1/n, please input n: ");
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
b.n = 0; b.p = 1; b.q = i;
add(&a, &b);
printf("S%-4d: %11ld %10lu/%lu\n", i, a.n, a.p, a.q);
}
return 0;
}
运行结果为：
Calculate Sn = 1/2 + 1/3 + 1/4 + ... 1/n, please input n: 24
S2 : 0 1/2
S3 : 0 5/6
S4 : 1 1/12
S5 : 1 17/60
S6 : 1 9/20
S7 : 1 83/140
S8 : 1 201/280
S9 : 1 2089/2520
S10 : 1 2341/2520
S11 : 2 551/27720
S12 : 2 2861/27720
S13 : 2 64913/360360
S14 : 2 90653/360360
S15 : 2 114677/360360
S16 : 2 274399/720720
S17 : 2 5385503/12252240
S18 : 2 2022061/4084080
S19 : 2 42503239/77597520
S20 : 2 9276623/15519504
S21 : 2 3338549/5173168
S22 : 2 3573693/5173168
S23 : 2 87368107/118982864
S24 : 2 276977179/356948592
我用的是Turbo C编译器，unsigned long int 是32位的，最大只能表示到 4,294,967,295，再大就溢出了，所以我只能计算到S24。谁有64位的long int的编译器，可以看一下能计算到多大的Sn。
wuyi8808 2002-10-15
- 打赏
- 举报
可以参考D.E.Knuth的《计算机程序设计艺术》第2卷中有理算术的论述。
whupyf 2002-10-15
- 打赏
- 举报
高中的求极限问题,
我不记得题目了,
好像是有一个范围的大于一个极限,小于一个极限,
可以证明,你最好找一下高考的题库,里面有.
记得我那时没做出来,所以现在也想不起来了
呵呵
我不记得题目了,
好像是有一个范围的大于一个极限,小于一个极限,
可以证明,你最好找一下高考的题库,里面有.
记得我那时没做出来,所以现在也想不起来了
呵呵
whupyf 2002-10-15
- 打赏
- 举报
float fun(float n)
{if (n==1) return 1;
else return 1/n+fun(n);
}
main()
{printf("%f",fun(100));
}
{if (n==1) return 1;
else return 1/n+fun(n);
}
main()
{printf("%f",fun(100));
}
d983074 2002-10-14
- 打赏
- 举报
解什么？
zyzyis 2002-10-14
- 打赏
- 举报
求和，但是若是用写程序的话，会有很大的误差，
如果用通分算100！ft........
各位讲讲好的算法，得到一个精确的和，用分数表示
如果用通分算100！ft........
各位讲讲好的算法，得到一个精确的和，用分数表示
zgtt 2002-10-14
- 打赏
- 举报
通分,然后算几个阶乘.
加载更多回复（11）
[C语言]程序改错题。爱因斯坦曾出过这样的一道数学题：有一条长阶梯，若每步跨2阶，最后剩下1阶；若每步跨3阶，最后剩下2阶；若每步跨5阶，最后剩下4阶；若每步跨6阶，最后剩下5阶；只有每步跨7阶...