e到底是什么?

今天看到一个下面这么一个简单的求极限问题-

一时恍惚了,为什么结果是e^m。 这个e是什么呢?

然后就百度了下,发现不少文章介绍这个e.

有几篇写得很赞 -

  1. An Intuitive Guide to Exponential Function e
  2. 阮一峰的文章:数学常数e的含义
  3. 知乎上牛人写的超长的介绍

下面摘录下第一篇文章中的部分内容,通过复利的方式来介绍e -

Money Changes Everything

But money is different. As soon as we earn a penny of interest, that penny can start earning micro-pennies of its own. We don’t need to wait until we earn a complete dollar in interest — fresh money doesn’t need to mature.

Based on our old formula, interest growth looks like this:

But again, this isn’t quite right: all the interest appears on the last day. Let’s zoom in and split the year into two chunks. We earn 100% interest every year, or 50% every 6 months. So, we earn 50 cents the first 6 months and another 50 cents in the last half of the year:

But this still isn’t right! Sure, our original dollar (Mr. Blue) earns a dollar over the course of a year. But after 6 months we had a 50-cent piece, ready to go, that we neglected! That 50 cents could have earned money on its own:

Because our rate is 50% per half year, that 50 cents would have earned 25 cents (50% times 50 cents). At the end of 1 year we’d have

  • Our original dollar (Mr. Blue)
  • The dollar Mr. Blue made (Mr. Green)
  • The 25 cents Mr. Green made (Mr. Red)

Giving us a total of $2.25. We gained $1.25 from our initial dollar, even better than doubling!

Let’s turn our return into a formula. The growth of two half-periods of 50% is:

Diving into Compound Growth

It’s time to step it up a notch. Instead of splitting growth into two periods of 50% increase, let’s split it into 3 segments of 33% growth. Who says we have to wait for 6 months before we start getting interest? Let’s get more granular in our counting.

Charting our growth for 3 compounded periods gives a funny picture:

Think of each color as shoveling money upwards towards the other colors (its children), at 33% per period:

Month 0: We start with Mr. Blue at $1.
Month 4: Mr. Blue has earned 1/3 dollar on himself, and creates Mr. Green, shoveling along 33 cents.
Month 8: Mr. Blue earns another 33 cents and gives it to Mr. Green, bringing Mr. Green up to 66 cents. Mr. Green has actually earned 33% on his previous value, creating 11 cents (33% * 33 cents). This 11 cents becomes Mr. Red.
Month 12: Things get a bit crazy. Mr. Blue earns another 33 cents and shovels it to Mr. Green, bringing Mr. Green to a full dollar. Mr. Green earns 33% return on his Month 8 value (66 cents), earning 22 cents. This 22 cents gets added to Mr. Red, who now totals 33 cents. And Mr. Red, who started at 11 cents, has earned 4 cents (33% * .11) on his own, creating Mr. Purple.
Phew! The final value after 12 months is: 1 + 1 + .33 + .04 or about 2.37.

Take some time to really understand what’s happening with this growth:

  • Each color earns interest on itself and hands it off to another color. The newly-created money can earn money of its own, and on the cycle goes.
  • I like to think of the original amount (Mr. Blue) as never changing. Mr. Blue shovels money to create Mr. Green, a steady 33 every 4 months since Mr. Blue does not change. In the diagram, Mr. Blue has a blue arrow showing how he feeds Mr. Green.
  • Mr. Green just happens to create and feed Mr. Red (green arrow), but Mr. Blue isn’t aware of this.
  • As Mr. Green grows over time (being constantly fed by Mr. Blue), he contributes more and more to Mr. Red. Between months 4-8 Mr. Green gives 11 cents to Mr. Red. Between months 8-12 Mr. Green gives 22 cents to Mr. Red, since Mr. Green was at 66 cents during Month 8. If we expanded the chart, Mr. Green would give 33 cents to Mr. Red, since Mr. Green reached a full dollar by Month 12.

Make sense? It’s tough at first — I even confused myself a bit while putting the charts together. But see that each dollar creates little helpers, who in turn create helpers, and so on.

We get a formula by using 3 periods in our growth equation:

We earned $1.37, even better than the $1.25 we got last time!

Can We Get Infinite Money?

Why not take even shorter time periods? How about every month, day, hour, or even nanosecond? Will our returns skyrocket?

Our return gets better, but only to a point. Try using different numbers of n in our magic formula to see our total return:

  • n (1 + 1/n)^n
  • 1 2
  • 2 2.25
  • 3 2.37
  • 5 2.488
  • 10 2.5937
  • 100 2.7048
  • 1,000 2.7169
  • 10,000 2.71814
  • 100,000 2.718268
  • 1,000,000 2.7182804
    ...

The numbers get bigger and converge around 2.718. Hey… wait a minute… that looks like e!

Yowza. In geeky math terms, e is defined to be that rate of growth if we continually compound 100% return on smaller and smaller time periods:

This limit appears to converge, and there are proofs to that effect. But as you can see, as we take finer time periods the total return stays around 2.718.

But what does it all mean?

The number e (2.718…) is the maximum possible result when compounding 100% growth for one time period. Sure, you started out expecting to grow from 1 to 2 (that’s a 100% increase, right?). But with each tiny step forward you create a little dividend that starts growing on its own. When all is said and done, you end up with e (2.718…) at the end of 1 time period, not 2. e is the maximum, what happens when we compound 100% as much as possible.

So, if we start with $1.00 and compound continuously at 100% return we get 1e. If we start with $2.00, we get 2e. If we start with $11.79, we get 11.79e.

e is like a speed limit (like c, the speed of light) saying how fast you can possibly grow using a continuous process. You might not always reach the speed limit, but it’s a reference point: you can write every rate of growth in terms of this universal constant.

(Aside: Be careful about separating the increase from the final result. 1 becoming e (2.718…) is an increase (growth rate) of 171.8%. e, by itself, is the final result you observe after all growth is taken into account (original + increase)).

What about different rates?

Good question. What if we grow at 50% annually, instead of 100%? Can we still use e?

Let’s see. The rate of 50% compound growth would look like this:

Hrm. What can we do here? Remember, 50% is the total return, and n is the number of periods to split the growth into for compounding. If we pick n=50, we can split our growth into 50 chunks of 1% interest:

Sure, it’s not infinity, but it’s pretty granular. Now imagine we also divided our regular rate of 100% into chunks of 1%:

Ah, something is emerging here. In our regular case, we have 100 cumulative changes of 1% each. In the 50% scenario, we have 50 cumulative changes of 1% each.

What is the difference between the two numbers? Well, it’s just half the number of changes:

This is pretty interesting. 50 / 100 = .5, which is the exponent we raise e to. This works in general: if we had a 300% growth rate, we could break it into 300 chunks of 1% growth. This would be triple the normal amount for a net rate of e3.

Even though growth can look like addition (+1%), we need to remember that it’s really a multiplication (x 1.01). This is why we use exponents (repeated multiplication) and square roots (e1/2 means “half” the number of changes, i.e. half the number of multiplications).

Although we picked 1%, we could have chosen any small unit of growth (.1%, .0001%, or even an infinitely small amount!). The key is that for any rate we pick, it’s just a new exponent on e:

What about different times?
Suppose we have 300% growth for 2 years. We’d multiply one year’s growth (e3) by itself:

And in general:

Because of the magic of exponents, we can avoid having two powers and just multiply rate and time together in a single exponent.

e到底是什么?的更多相关文章

  1. 拨开迷雾,找回自我:DDD 应对具体业务场景,Domain Model 到底如何设计?

    写在前面 除了博文内容之外,和 netfocus 兄的讨论,也可以让你学到很多(至少我是这样),不要错过哦. 阅读目录: 迷雾森林 找回自我 开源地址 后记 毫无疑问,领域驱动设计的核心是领域模型,领 ...

  2. Js new到底发生了什么

    在Js中,我们使用了new关键字来进行实例化 那么在这个new的过程中到底发生了什么? 关于构造函数的return 正常来讲构造函数中是不用写return语句的,因为它会默认返回新创建的对象. 但是, ...

  3. 电信计费业务:预后融合OCS到底应该实扣还是虚扣?

    引入OCS的初衷之一是为了让计费系统能够参与到用户的通讯控制中来,也就是所谓的实时信控.用户在没有余额时,通讯就会被停止,不会造成"天价欠费 ",一方面保障用户的利益,一方面也保障 ...

  4. 港真,到底应该选择OA还是BPM?

    越来越多企业意识到流程管理的重要性,但是,选择OA还是BPM,却让他们产生了选择困难症. 一方面,企业皆注重流程的高效运转,最好内外部的业务都能用一个系统来解决.所有流程一天就能上线什么的,那就更好啦 ...

  5. 四、可空类型Nullable<T>到底是什么鬼

    值类型为什么不可以为空 首先我们都知道引用类型默认值都是null,而值类型的默认值都有非null. 为什么引用类型可以为空?因为引用类型变量都是保存一个对象的地址引用(就像一个url对应一个页面),而 ...

  6. 在开发中到底要不要用var?

    var是.net的一个语法糖,在Resharper中推荐都使用这个关键字,平常我也是经常用:但是在跟其他程序员推广使用时,他的一些考虑引发了我的深思,到底该不该使用这个关键字呢? 我使用的理由 我使用 ...

  7. 阿里的weex框架到底是什么

    title: 阿里的weex框架到底是什么 date: 2016-09-27 10:22:34 tags: vue, weex category: 技术总结 --- weex 工作原理 首先看下官方的 ...

  8. 全局变量 HInstance 到底是在什么时候赋值的?

    在学习 资源文件 和 钩子函数 时, 经常用到当前模块句柄(HInstance)这个全局变量. 今天特别想知道, 它到底是在什么时候给赋值的. 输入 HInstance; "Ctrl+鼠标& ...

  9. 从问题看本质:socket到底是什么?

    一.问题的引入——socket的引入是为了解决不同计算机间进程间通信的问题 1.socket与进程的关系 1).socket与进程间的关系:socket   用来让一个进程和其他的进程互通信息(IPC ...

  10. char varchar nchar nvarcharar到底有多大区别

    首先说明下,ASP.NET MVC系列还在龟速翻译中. 工作好多年,基础知识甚是薄弱,决定以后在coding(cv操作)的时候尽量多google下,然后总结下来,目的有三:     1. 加深自己的理 ...

随机推荐

  1. ADS ARM 汇编和GNU ARM汇编

    Linux/Unix内核源代码用的编译器是GCC,而GCC采用的是AT&T的汇编格式,这与ADS下使用的汇编格式是不同的. 两种汇编格式的部分对比如下: GNU ARM汇编 ADS ARM汇编 ...

  2. RESTful到底是什么玩意??

      0. REST不是"rest"这个单词,而是几个单词缩写.: 1. REST描述的是在网络中client和server的一种交互形式:REST本身不实用,实用的是如何设计 RE ...

  3. 恭喜您成为2014年度Microsoft MVP!

  4. repr

    >>> import datetime >>> today=datetime.datetime.now() >>> today datetime. ...

  5. WIFI物联网平台微信端开发分享

    本文由企鹅圈原创成员Hunter_Zhu贡献. 本篇文章是基于近期一个项目微信端开发过程的一个总结.文中主要介绍了云智易平台下微信端开发的流程.该平台提供的主要功能以及此次H5开发使用到的一些UI组件 ...

  6. PHP-二进制文件和文本文件的区别

    一.文本文件和二进制文件的定义 计算机上所有文件存储在存储设备上都是二进制的, 所以文本文件和二进制文件的区别并不是物理上的, 而是逻辑上的!简单来说, 文本文件是基于字符编码的文件, 常见的编码有A ...

  7. HDUOJ-----2571跳舞毯

    跳舞毯 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submiss ...

  8. HDUOJ------1058 Humble Numbers

    Humble Numbers Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)To ...

  9. HDUOJ----2063过山车

    过山车 Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submiss ...

  10. Python实现 K_Means聚类算法

    使用 Python实现 K_Means聚类算法: 问题定义 聚类问题是数据挖掘的基本问题,它的本质是将n个数据对象划分为 k个聚类,以便使得所获得的聚类满足以下条件: 同一聚类中的数据对象相似度较高 ...