Add the euqal, linspace, matmul the apis for chinese doc

Add the Chinese doc for the api of equal, linspace, matmul

doc/fluid/api_cn/tensor_cn/equal_cn.rst

+.. _cn_api_tensor_equal:
+
 equal
 -------------------------------
-**版本升级，文档正在开发中**
+.. py:function:: paddle.equal(x, y, axis=-1, name=None)
+
+该OP返回 :math:`x==y` 逐元素比较x和y是否相等，所有的元素都相同则返回True，否则返回False。
+
+参数：
+    - **x** (Variable) - 输入Tensor，支持的数据类型包括 float32， float64，int32， int64。
+    - **y** (Variable) - 输入Tensor，支持的数据类型包括 float32， float64， int32， int64。
+    - **axis** (int, 可选) - 如果输入的两个Tensor的维度不相同，并且如果y的维度是x的一部分, 那就可以通过broadcast的方式来进行op计算。axis是进行broadcast的开始的维度，具体broadcast的方式可以参考elementwise_add。 
+    - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
+    
+
+返回：输出结果的Tensor，输出Tensor只有一个元素值，元素值是True或者False，Tensor数据类型为bool。
+
+返回类型：变量（Variable）
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    import paddle
+    import numpy as np
+    label = fluid.layers.assign(np.array([3, 4], dtype="int32"))
+    label_1 = fluid.layers.assign(np.array([1, 2], dtype="int32"))
+    limit = fluid.layers.assign(np.array([3, 4], dtype="int32"))
+    out1 = paddle.equal(x=label, y=limit) #out1=[True]
+    out2 = paddle.equal(x=label_1, y=limit) #out2=[False]
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    import paddle
+    import numpy as np
+    def gen_data():
+        return {
+              "x": np.ones((2, 3, 4, 5)).astype('float32'),
+              "y": np.zeros((3, 4)).astype('float32')
+          }
+    x = fluid.data(name="x", shape=[2,3,4,5], dtype='float32')
+    y = fluid.data(name="y", shape=[3,4], dtype='float32')
+    out = paddle.equal(x, y, axis=1)
+    place = fluid.CPUPlace()
+    exe = fluid.Executor(place)
+    res = exe.run(feed=gen_data(),
+                      fetch_list=[out])
+    print(res[0]) #[False]

doc/fluid/api_cn/tensor_cn/linspace_cn.rst

+.. _cn_api_tensor_linspace:
+
 linspace
 -------------------------------
-**版本升级，文档正在开发中**
+
+.. py:function:: paddle.linspace(start, stop, num, dtype, out=None, device=None, name=None)
+
+该OP在给定区间内返回固定数目的均匀间隔的值。
+
+**注意：该OP不进行梯度计算**
+ 
+参数：
+    - **start** (float|Variable) – start是区间开始的变量，可以是一个浮点标量，或是一个shape为[1]的Tensor，该Tensor的数据类型可以是float32或者是float64。
+    - **stop** (float|Variable) – end是区间结束的变量，可以是一个浮点标量，或是一个shape为[1]的Tensor，该Tensor的数据类型可以是float32或者是float64。
+    - **num** (int|Variable) – num是给定区间内需要划分的区间数，可以是一个整型标量，或是一个shape为[1]的Tensor，该Tensor的数据类型需为int32。
+    - **dtype** (string) – 输出Tensor的数据类型，可以是‘float32’或者是‘float64’。
+    - **out** (Variable，可选) – 指定存储运算结果的Tensor。如果设置为None或者不设置，将创建新的Tensor存储运算结果，默认值为None。
+    - **device** (str，可选) – 选择在哪个设备运行该操作，可选值包括None，'cpu'和'gpu'。如果 ``device``  为None，则将选择运行Paddle程序的设备，默认为None。
+    - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
+
+返回：输出结果的数据类型是float32或float64，表示等间隔划分结果的1-D Tensor，该Tensor的shape大小为 :math:`[num]` ，在mum为1的情况下，仅返回包含start元素值的Tensor。
+
+返回类型：Variable
+
+**代码示例**：
+
+.. code-block:: python
+
+      import paddle
+      data = paddle.linspace(0, 10, 5, dtype='float32') # [0.0,  2.5,  5.0,  7.5, 10.0]
+      data = paddle.linspace(0, 10, 1, dtype='float32') # [0.0]
+

doc/fluid/api_cn/tensor_cn/matmul_cn.rst

+.. _cn_api_tensor_matmul:
+
 matmul
 -------------------------------
-**版本升级，文档正在开发中**
+
+.. py:function:: paddle.matmul(x, y, transpose_x=False, transpose_y=False, alpha=1.0, name=None)
+
+输入 ``x`` 和输入 ``y`` 矩阵相乘。
+
+两个输入的形状可为任意维度，但当任一输入维度大于3时，两个输入的维度必须相等。
+实际的操作取决于 ``x`` 、 ``y`` 的维度和 ``transpose_x`` 、 ``transpose_y`` 的布尔值。具体如下：
+
+- 如果 ``transpose`` 为真，则对应 Tensor 的后两维会转置。假定 ``x`` 是一个 shape=[D] 的一维 Tensor，则 ``x`` 非转置形状为 [1, D]，转置形状为 [D, 1]。转置之后的输入形状需满足矩阵乘法要求，即 `x_width` 与 `y_height` 相等。
+
+- 转置后，输入的两个 Tensor 维度将为 2-D 或 n-D，将根据下列规则矩阵相乘：
+    - 如果两个矩阵都是 2-D，则同普通矩阵一样进行矩阵相乘。
+    - 如果任意一个矩阵是 n-D，则将其视为带 batch 的二维矩阵乘法。
+
+- 如果原始 Tensor x 或 y 的秩为 1 且未转置，则矩阵相乘后的前置或附加维度 1 将移除。
+
+参数：
+    - **x** (Variable) : 输入变量，类型为 Tensor 或 LoDTensor，数据类型为float32， float64，GPU设备下支持float16。
+    - **y** (Variable) : 输入变量，类型为 Tensor 或 LoDTensor，数据类型为float32， float64，GPU设备下支持float16。
+    - **transpose_x** (bool，可选) : 相乘前是否转置 x，默认值为False。
+    - **transpose_y** (bool，可选) : 相乘前是否转置 y，默认值为False。
+    - **alpha** (float，可选) : 输出比例，默认为 3.0。
+    - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
+
+返回：
+    - Variable (Tensor / LoDTensor)，矩阵相乘后的结，数据类型和输入数据类型一致。
+
+返回类型：
+    - Variable（变量）。
+
+::
+
+    * 例 1:
+
+    x: [B, ..., M, K], y: [B, ..., K, N]
+    # paddle.matmul(x, y)  # out: [B, ..., M, N]
+
+    * 例 2:
+
+    x: [B, M, K], y: [B, K, N]
+    # paddle.matmul(x, y)  # out: [B, M, N]
+
+    * 例 3:
+
+    x: [B, M, K], y: [K, N]
+    # paddle.matmul(x, y)  # out: [B, M, N]
+
+    * 例 4:
+
+    x: [M, K], y: [K, N]
+    # paddle.matmul(x, y)  # out: [M, N]
+
+    * 例 5:
+
+    x: [B, M, K], y: [K]
+    # paddle.matmul(x, y)  # out: [B, M]
+
+    * 例 6:
+
+    x: [K], y: [K]
+    # paddle.matmul(x, y)  # out: [1]
+
+    * 例 7:
+
+    x: [M], y: [N]
+    # paddle.matmul(x, y, True, True)  # out: [M, N]
+
+
+**代码示例**：
+
+.. code-block:: python
+
+    import paddle.fluid as fluid
+    x = fluid.data(name='x', shape=[2, 3], dtype='float32')
+    y = fluid.data(name='y', shape=[3, 2], dtype='float32')
+    out = paddle.matmul(x, y, True, True)
+