{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hello world\n" ] } ], "source": [ "greeting = \"Hello world\"\n", "println(greeting)" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(0.9800665778412416, 2.302585092994046, 1.22)" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a,b,c = cos(0.2), log(10), abs(-1.22)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.9800665778412416" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "search: \u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ms\u001b[22m \u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ms\u001b[22mh \u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ms\u001b[22md \u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ms\u001b[22mc \u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ms\u001b[22mpi a\u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ms\u001b[22m a\u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ms\u001b[22mh a\u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ms\u001b[22md sin\u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ms\u001b[22m \u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22mn\u001b[0m\u001b[1ms\u001b[22mt \u001b[0m\u001b[1mc\u001b[22ml\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ms\u001b[22me is\u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22mn\u001b[0m\u001b[1ms\u001b[22mt\n", "\n" ] }, { "data": { "text/latex": [ "\\begin{verbatim}\n", "cos(x)\n", "\\end{verbatim}\n", "Compute cosine of \\texttt{x}, where \\texttt{x} is in radians.\n", "\n", "\\rule{\\textwidth}{1pt}\n", "\\begin{verbatim}\n", "cos(A::AbstractMatrix)\n", "\\end{verbatim}\n", "Compute the matrix cosine of a square matrix \\texttt{A}.\n", "\n", "If \\texttt{A} is symmetric or Hermitian, its eigendecomposition (\\href{@ref}{\\texttt{eigen}}) is used to compute the cosine. Otherwise, the cosine is determined by calling \\href{@ref}{\\texttt{exp}}.\n", "\n", "\\section{Examples}\n", "\\begin{verbatim}\n", "julia> cos(fill(1.0, (2,2)))\n", "2×2 Array{Float64,2}:\n", " 0.291927 -0.708073\n", " -0.708073 0.291927\n", "\\end{verbatim}\n" ], "text/markdown": [ "```\n", "cos(x)\n", "```\n", "\n", "Compute cosine of `x`, where `x` is in radians.\n", "\n", "---\n", "\n", "```\n", "cos(A::AbstractMatrix)\n", "```\n", "\n", "Compute the matrix cosine of a square matrix `A`.\n", "\n", "If `A` is symmetric or Hermitian, its eigendecomposition ([`eigen`](@ref)) is used to compute the cosine. Otherwise, the cosine is determined by calling [`exp`](@ref).\n", "\n", "# Examples\n", "\n", "```jldoctest\n", "julia> cos(fill(1.0, (2,2)))\n", "2×2 Array{Float64,2}:\n", " 0.291927 -0.708073\n", " -0.708073 0.291927\n", "```\n" ], "text/plain": [ "\u001b[36m cos(x)\u001b[39m\n", "\n", " Compute cosine of \u001b[36mx\u001b[39m, where \u001b[36mx\u001b[39m is in radians.\n", "\n", " ────────────────────────────────────────────────────────────────────────────\n", "\n", "\u001b[36m cos(A::AbstractMatrix)\u001b[39m\n", "\n", " Compute the matrix cosine of a square matrix \u001b[36mA\u001b[39m.\n", "\n", " If \u001b[36mA\u001b[39m is symmetric or Hermitian, its eigendecomposition (\u001b[36meigen\u001b[39m) is used to\n", " compute the cosine. Otherwise, the cosine is determined by calling \u001b[36mexp\u001b[39m.\n", "\n", "\u001b[1m Examples\u001b[22m\n", "\u001b[1m ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n", "\n", "\u001b[36m julia> cos(fill(1.0, (2,2)))\u001b[39m\n", "\u001b[36m 2×2 Array{Float64,2}:\u001b[39m\n", "\u001b[36m 0.291927 -0.708073\u001b[39m\n", "\u001b[36m -0.708073 0.291927\u001b[39m" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "? cos" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.0" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cos(0)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-1.0" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cos(π)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "6.123233995736766e-17" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cos(π/2)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Irrational{:π}" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "typeof(π)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/html": [ "12 methods for generic function muladd:" ], "text/plain": [ "# 12 methods for generic function \"muladd\":\n", "[1] muladd(a::Float16, b::Float16, c::Float16) in Base at float.jl:406\n", "[2] muladd(x::Float64, y::Float64, z::Float64) in Base at float.jl:404\n", "[3] muladd(x::Float32, y::Float32, z::Float32) in Base at float.jl:403\n", "[4] muladd(z::Complex, w::Complex, x::Complex) in Base at complex.jl:272\n", "[5] muladd(x::Real, z::Complex, y::Number) in Base at complex.jl:315\n", "[6] muladd(z::Complex, x::Real, y::Real) in Base at complex.jl:316\n", "[7] muladd(z::Complex, x::Real, w::Complex) in Base at complex.jl:317\n", "[8] muladd(x::Real, y::Real, z::Complex) in Base at complex.jl:319\n", "[9] muladd(z::Complex, w::Complex, x::Real) in Base at complex.jl:320\n", "[10] muladd(x::T, y::T, z::T) where T<:Number in Base at promotion.jl:397\n", "[11] muladd(x::Number, y::Number, z::Number) in Base at promotion.jl:348\n", "[12] muladd(x, y, z) in Base.Math at math.jl:1012" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "methods(muladd)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "myfunc (generic function with 1 method)" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "myfunc(firstvar) = 20* firstvar" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "6664.4439999999995" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "myfunc(333.2222)" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "addxtoy (generic function with 1 method)" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "addxtoy(x,y) = x + y" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "18.8" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "addxtoy(22,-3.2)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "nextfunc (generic function with 1 method)" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "function nextfunc(x,y,z)\n", " x+y*z\n", "end" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "showdebugprintln (generic function with 1 method)" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "function showdebugprintln(testvar)\n", " println(\"Show inside the showdebugprintln() now\")\n", " println(\"The type of testvar is $(typeof(testvar)) and the value of testvar is $testvar\")\n", "end" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2-element Array{Any,1}:\n", " '1'\n", " 2.0 " ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = ['1',2.]" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Show inside the showdebugprintln() now\n", "The type of testvar is Array{Any,1} and the value of testvar is Any['1', 2.0]\n" ] } ], "source": [ "showdebugprintln(a)" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "mycos (generic function with 1 method)" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mycos(x) = cos(x)" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.955336489125606" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mycos(.3)" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "mycos (generic function with 2 methods)" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mycos(adj,hyp) = adj/hyp" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.9230769230769231" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mycos(12,13)" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/html": [ "2 methods for generic function mycos:" ], "text/plain": [ "# 2 methods for generic function \"mycos\":\n", "[1] mycos(x) in Main at In[28]:1\n", "[2] mycos(adj, hyp) in Main at In[30]:1" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "methods(mycos)" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "mycos (generic function with 3 methods)" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mycos(thet::Float64) = cos(thet)" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "84.0" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "60 \\ 5040" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "search: \u001b[0m\u001b[1m\\\u001b[22m\n", "\n" ] }, { "data": { "text/latex": [ "\\begin{verbatim}\n", "\\(x, y)\n", "\\end{verbatim}\n", "Left division operator: multiplication of \\texttt{y} by the inverse of \\texttt{x} on the left. Gives floating-point results for integer arguments.\n", "\n", "\\section{Examples}\n", "\\begin{verbatim}\n", "julia> 3 \\ 6\n", "2.0\n", "\n", "julia> inv(3) * 6\n", "2.0\n", "\n", "julia> A = [4 3; 2 1]; x = [5, 6];\n", "\n", "julia> A \\ x\n", "2-element Array{Float64,1}:\n", " 6.5\n", " -7.0\n", "\n", "julia> inv(A) * x\n", "2-element Array{Float64,1}:\n", " 6.5\n", " -7.0\n", "\\end{verbatim}\n", "\\rule{\\textwidth}{1pt}\n", "\\begin{verbatim}\n", "\\(A, B)\n", "\\end{verbatim}\n", "Matrix division using a polyalgorithm. For input matrices \\texttt{A} and \\texttt{B}, the result \\texttt{X} is such that \\texttt{A*X == B} when \\texttt{A} is square. The solver that is used depends upon the structure of \\texttt{A}. If \\texttt{A} is upper or lower triangular (or diagonal), no factorization of \\texttt{A} is required and the system is solved with either forward or backward substitution. For non-triangular square matrices, an LU factorization is used.\n", "\n", "For rectangular \\texttt{A} the result is the minimum-norm least squares solution computed by a pivoted QR factorization of \\texttt{A} and a rank estimate of \\texttt{A} based on the R factor.\n", "\n", "When \\texttt{A} is sparse, a similar polyalgorithm is used. For indefinite matrices, the \\texttt{LDLt} factorization does not use pivoting during the numerical factorization and therefore the procedure can fail even for invertible matrices.\n", "\n", "\\section{Examples}\n", "\\begin{verbatim}\n", "julia> A = [1 0; 1 -2]; B = [32; -4];\n", "\n", "julia> X = A \\ B\n", "2-element Array{Float64,1}:\n", " 32.0\n", " 18.0\n", "\n", "julia> A * X == B\n", "true\n", "\\end{verbatim}\n", "\\rule{\\textwidth}{1pt}\n", "\\begin{verbatim}\n", "(\\)(F::QRSparse, B::StridedVecOrMat)\n", "\\end{verbatim}\n", "Solve the least squares problem $\\min\\|Ax - b\\|^2$ or the linear system of equations $Ax=b$ when \\texttt{F} is the sparse QR factorization of $A$. A basic solution is returned when the problem is underdetermined.\n", "\n", "\\section{Examples}\n", "\\begin{verbatim}\n", "julia> A = sparse([1,2,4], [1,1,1], [1.0,1.0,1.0], 4, 2)\n", "4×2 SparseMatrixCSC{Float64,Int64} with 3 stored entries:\n", " [1, 1] = 1.0\n", " [2, 1] = 1.0\n", " [4, 1] = 1.0\n", "\n", "julia> qr(A)\\fill(1.0, 4)\n", "2-element Array{Float64,1}:\n", " 1.0\n", " 0.0\n", "\\end{verbatim}\n" ], "text/markdown": [ "```\n", "\\(x, y)\n", "```\n", "\n", "Left division operator: multiplication of `y` by the inverse of `x` on the left. Gives floating-point results for integer arguments.\n", "\n", "# Examples\n", "\n", "```jldoctest\n", "julia> 3 \\ 6\n", "2.0\n", "\n", "julia> inv(3) * 6\n", "2.0\n", "\n", "julia> A = [4 3; 2 1]; x = [5, 6];\n", "\n", "julia> A \\ x\n", "2-element Array{Float64,1}:\n", " 6.5\n", " -7.0\n", "\n", "julia> inv(A) * x\n", "2-element Array{Float64,1}:\n", " 6.5\n", " -7.0\n", "```\n", "\n", "---\n", "\n", "```\n", "\\(A, B)\n", "```\n", "\n", "Matrix division using a polyalgorithm. For input matrices `A` and `B`, the result `X` is such that `A*X == B` when `A` is square. The solver that is used depends upon the structure of `A`. If `A` is upper or lower triangular (or diagonal), no factorization of `A` is required and the system is solved with either forward or backward substitution. For non-triangular square matrices, an LU factorization is used.\n", "\n", "For rectangular `A` the result is the minimum-norm least squares solution computed by a pivoted QR factorization of `A` and a rank estimate of `A` based on the R factor.\n", "\n", "When `A` is sparse, a similar polyalgorithm is used. For indefinite matrices, the `LDLt` factorization does not use pivoting during the numerical factorization and therefore the procedure can fail even for invertible matrices.\n", "\n", "# Examples\n", "\n", "```jldoctest\n", "julia> A = [1 0; 1 -2]; B = [32; -4];\n", "\n", "julia> X = A \\ B\n", "2-element Array{Float64,1}:\n", " 32.0\n", " 18.0\n", "\n", "julia> A * X == B\n", "true\n", "```\n", "\n", "---\n", "\n", "```\n", "(\\)(F::QRSparse, B::StridedVecOrMat)\n", "```\n", "\n", "Solve the least squares problem $\\min\\|Ax - b\\|^2$ or the linear system of equations $Ax=b$ when `F` is the sparse QR factorization of $A$. A basic solution is returned when the problem is underdetermined.\n", "\n", "# Examples\n", "\n", "```jldoctest\n", "julia> A = sparse([1,2,4], [1,1,1], [1.0,1.0,1.0], 4, 2)\n", "4×2 SparseMatrixCSC{Float64,Int64} with 3 stored entries:\n", " [1, 1] = 1.0\n", " [2, 1] = 1.0\n", " [4, 1] = 1.0\n", "\n", "julia> qr(A)\\fill(1.0, 4)\n", "2-element Array{Float64,1}:\n", " 1.0\n", " 0.0\n", "```\n" ], "text/plain": [ "\u001b[36m \\(x, y)\u001b[39m\n", "\n", " Left division operator: multiplication of \u001b[36my\u001b[39m by the inverse of \u001b[36mx\u001b[39m on the left.\n", " Gives floating-point results for integer arguments.\n", "\n", "\u001b[1m Examples\u001b[22m\n", "\u001b[1m ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n", "\n", "\u001b[36m julia> 3 \\ 6\u001b[39m\n", "\u001b[36m 2.0\u001b[39m\n", "\u001b[36m \u001b[39m\n", "\u001b[36m julia> inv(3) * 6\u001b[39m\n", "\u001b[36m 2.0\u001b[39m\n", "\u001b[36m \u001b[39m\n", "\u001b[36m julia> A = [4 3; 2 1]; x = [5, 6];\u001b[39m\n", "\u001b[36m \u001b[39m\n", "\u001b[36m julia> A \\ x\u001b[39m\n", "\u001b[36m 2-element Array{Float64,1}:\u001b[39m\n", "\u001b[36m 6.5\u001b[39m\n", "\u001b[36m -7.0\u001b[39m\n", "\u001b[36m \u001b[39m\n", "\u001b[36m julia> inv(A) * x\u001b[39m\n", "\u001b[36m 2-element Array{Float64,1}:\u001b[39m\n", "\u001b[36m 6.5\u001b[39m\n", "\u001b[36m -7.0\u001b[39m\n", "\n", " ────────────────────────────────────────────────────────────────────────────\n", "\n", "\u001b[36m \\(A, B)\u001b[39m\n", "\n", " Matrix division using a polyalgorithm. For input matrices \u001b[36mA\u001b[39m and \u001b[36mB\u001b[39m, the\n", " result \u001b[36mX\u001b[39m is such that \u001b[36mA*X == B\u001b[39m when \u001b[36mA\u001b[39m is square. The solver that is used\n", " depends upon the structure of \u001b[36mA\u001b[39m. If \u001b[36mA\u001b[39m is upper or lower triangular (or\n", " diagonal), no factorization of \u001b[36mA\u001b[39m is required and the system is solved with\n", " either forward or backward substitution. For non-triangular square matrices,\n", " an LU factorization is used.\n", "\n", " For rectangular \u001b[36mA\u001b[39m the result is the minimum-norm least squares solution\n", " computed by a pivoted QR factorization of \u001b[36mA\u001b[39m and a rank estimate of \u001b[36mA\u001b[39m based\n", " on the R factor.\n", "\n", " When \u001b[36mA\u001b[39m is sparse, a similar polyalgorithm is used. For indefinite matrices,\n", " the \u001b[36mLDLt\u001b[39m factorization does not use pivoting during the numerical\n", " factorization and therefore the procedure can fail even for invertible\n", " matrices.\n", "\n", "\u001b[1m Examples\u001b[22m\n", "\u001b[1m ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n", "\n", "\u001b[36m julia> A = [1 0; 1 -2]; B = [32; -4];\u001b[39m\n", "\u001b[36m \u001b[39m\n", "\u001b[36m julia> X = A \\ B\u001b[39m\n", "\u001b[36m 2-element Array{Float64,1}:\u001b[39m\n", "\u001b[36m 32.0\u001b[39m\n", "\u001b[36m 18.0\u001b[39m\n", "\u001b[36m \u001b[39m\n", "\u001b[36m julia> A * X == B\u001b[39m\n", "\u001b[36m true\u001b[39m\n", "\n", " ────────────────────────────────────────────────────────────────────────────\n", "\n", "\u001b[36m (\\)(F::QRSparse, B::StridedVecOrMat)\u001b[39m\n", "\n", " Solve the least squares problem \u001b[35m\\min\\|Ax - b\\|^2\u001b[39m or the linear system of\n", " equations \u001b[35mAx=b\u001b[39m when \u001b[36mF\u001b[39m is the sparse QR factorization of \u001b[35mA\u001b[39m. A basic solution\n", " is returned when the problem is underdetermined.\n", "\n", "\u001b[1m Examples\u001b[22m\n", "\u001b[1m ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n", "\n", "\u001b[36m julia> A = sparse([1,2,4], [1,1,1], [1.0,1.0,1.0], 4, 2)\u001b[39m\n", "\u001b[36m 4×2 SparseMatrixCSC{Float64,Int64} with 3 stored entries:\u001b[39m\n", "\u001b[36m [1, 1] = 1.0\u001b[39m\n", "\u001b[36m [2, 1] = 1.0\u001b[39m\n", "\u001b[36m [4, 1] = 1.0\u001b[39m\n", "\u001b[36m \u001b[39m\n", "\u001b[36m julia> qr(A)\\fill(1.0, 4)\u001b[39m\n", "\u001b[36m 2-element Array{Float64,1}:\u001b[39m\n", "\u001b[36m 1.0\u001b[39m\n", "\u001b[36m 0.0\u001b[39m" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "? \\" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "84.0" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "5040/60" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "addone (generic function with 1 method)" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "addone(x::Int64) = x+1" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "ename": "MethodError", "evalue": "MethodError: no method matching addone(::Float64)\nClosest candidates are:\n addone(!Matched::Int64) at In[38]:1", "output_type": "error", "traceback": [ "MethodError: no method matching addone(::Float64)\nClosest candidates are:\n addone(!Matched::Int64) at In[38]:1", "", "Stacktrace:", " [1] top-level scope at In[42]:1" ] } ], "source": [ "addone(ceil(1.2)*10)" ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(1, 2)" ] }, "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a,b=1,2" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(2, 1)" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a,b=b,a" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "22\n" ] } ], "source": [ "function test(input)\n", " println(\"$input\"^2)\n", "end\n", "\n", "test(2)" ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "22\n" ] }, { "data": { "text/plain": [ "Nothing" ] }, "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ "typeof(test(2))" ] }, { "cell_type": "code", "execution_count": 56, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "add2 (generic function with 1 method)" ] }, "execution_count": 56, "metadata": {}, "output_type": "execute_result" } ], "source": [ "add2(x,y) = return x + y" ] }, { "cell_type": "code", "execution_count": 57, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "12\n" ] } ], "source": [ "println(add2(5, 7))" ] }, { "cell_type": "code", "execution_count": 58, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "coordinates (generic function with 3 methods)" ] }, "execution_count": 58, "metadata": {}, "output_type": "execute_result" } ], "source": [ "function coordinates(x, y=0, z=0)\n", " println(\"($x, $y, $z)\")\n", "end" ] }, { "cell_type": "code", "execution_count": 59, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(1, 0, 2)\n" ] } ], "source": [ "coordinates(1,0,2)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Julia 1.2.0", "language": "julia", "name": "julia-1.2" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", "version": "1.2.0" } }, "nbformat": 4, "nbformat_minor": 4 }