resolve conflitc

Author: jverzani

.travis.yml

@@ -3,13 +3,10 @@ os:
   - linux
   - osx
 julia:
-  - 0.4
-  - 0.5
   - 0.6
   - nightly
 matrix:
   allow_failures:
-    - julia: 0.6
     - julia: nightly
 git:
     depth: 99999

README.md

@@ -1,7 +1,3 @@
-[![SymPy](http://pkg.julialang.org/badges/SymPy_0.4.svg)](http://pkg.julialang.org/?pkg=SymPy&ver=0.4)
- 
-[![SymPy](http://pkg.julialang.org/badges/SymPy_0.5.svg)](http://pkg.julialang.org/?pkg=SymPy&ver=0.5)
- 
 [![SymPy](http://pkg.julialang.org/badges/SymPy_0.6.svg)](http://pkg.julialang.org/?pkg=SymPy&ver=0.6) 
 
 Linux: [![Build Status](https://travis-ci.org/JuliaPy/SymPy.jl.svg?branch=master)](https://travis-ci.org/JuliaPy/SymPy.jl)
@@ -17,7 +13,7 @@ Windows: [![Build Status](https://ci.appveyor.com/api/projects/status/github/Jul
 The `SymPy` package  (`http://sympy.org/`)  is a Python library for symbolic mathematics. 
 
 With the excellent `PyCall` package of `julia`, one has access to the
-many features of `SymPy` from a `julia` session.
+many features of `SymPy` from within a `Julia` session.
 
 This `SymPy` package provides a light interface for _some_ of the
 features of `SymPy` that makes working with `SymPy` objects a bit
@@ -35,7 +31,7 @@ installed on your system. If `PyCall` is installed using `Conda`
 underlying `SymPy` library will be installed via `Conda` when the
 package is first loaded. Otherwise, installing both `Python` and
 `SymPy` (which also requires `mpmath`) can be done by other means.
-The `Anaconda` distribution is suggested, as it provides a single
+In this case, the `Anaconda` distribution is suggested, as it provides a single
 installation of `Python` that includes `SymPy` and many other
 scientifice libraries that can be profitably accessed within `Julia`
 via `PyCall`. (Otherwise, install `Python` then download the `sympy`
@@ -79,20 +75,20 @@ This gets replaced by a more `julia`n syntax:
 
 ```
 using SymPy                    
-x = symbols("x")		       # or   @syms x, Sym("x"), or  Sym(:x)
+x = symbols("x")		       # or   @vars x, Sym("x"), or  Sym(:x)
 y = sin(pi*x)
 y(1)                           # Does subs(y, x, 1). Use y(x=>1) to be specific as to which symbol to substitute
 ```
 
 The object `x` we create is of type `Sym`, a simple proxy for the
 underlying `PyObject`. We then overload the familiar math functions so
 that working with symbolic expressions can use natural `julia`
-idioms. The final result is here is a symbolic value of `0`, which
+idioms. The final result  here is a symbolic value of `0`, which
 prints as `0` and not `PyObject 0`. To convert it into a numeric value
 within `Julia`, the `N` function may be used, which acts like the
-`float` call, only attempts to preserve the variable type.
+`float` call, only there is an attempt to preserve the variable type.
 
-(There is a subtlety, the value of `pi` here is converted to the
+(There is a subtlety, the value of `pi` here (an `Irrational` in `Julia`) is converted to the
 symbolic `PI`, but in general won't be if the math constant is coerced
 to a floating point value before it encounters a symbolic object. It
 is better to just use the symbolic value `PI`, an alias for `sympy.pi`
@@ -104,9 +100,23 @@ only a portion of the `SymPy` interface is exposed. To call an
 underlying SymPy method, the `getindex` method is overloaded for
 `symbol` indices so that `ex[:meth_name](...)` dispatches to either to
 SymPy's `ex.meth_name(...)` or `meth_name(ex, ...)`, as possible.
+
+
 There is a `sympy` string macro to simplify this a bit, with the call
-looking like: `sympy"meth_name"(...)`, for example `sympy"harmonic"(10)`.
+looking like: `sympy"meth_name"(...)`, for example
+`sympy"harmonic"(10)`. For example, the above could also be done
+through:
+
+```
+@vars x
+y = sympy"sin"(pi * x)
+y(1)
+```
 
+As calling the underlying SymPy function is not difficult, the
+interface exposed through overloading `Julia`'s methods attempts to
+keep similar functionality to the familiar `Julia` method when there is
+a discrepancy between conventions.
 
 ## Notes
 

REQUIRE

@@ -1,5 +1,6 @@
-julia 0.4
-Compat 0.25.0
+julia 0.6.0
+Compat 0.33.0
 PyCall 1.6.0
 RecipesBase 0.2.3
-BaseTestNext 0.2.2
+SpecialFunctions 0.3.4
+

appveyor.yml

@@ -1,32 +1,29 @@
 environment:
   matrix:
 
-# 0.4 - 0.6
+# 0.6 - latest
 
-  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.4/julia-0.4-latest-win32.exe"
+  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.6/julia-0.6-latest-win32.exe"
     PYTHONDIR: "use_conda"
     PYTHON: "use_conda"
 
-  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x64/0.4/julia-0.4-latest-win64.exe"
+  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x64/0.6/julia-0.6-latest-win64.exe"
     PYTHONDIR: "use_conda"
     PYTHON: "use_conda"
 
-  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.5/julia-0.5-latest-win32.exe"
-    PYTHONDIR: "use_conda"
-    PYTHON: "use_conda"
-    
-  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x64/0.5/julia-0.5-latest-win64.exe"
-    PYTHONDIR: "use_conda"
-    PYTHON: "use_conda"
-    
-  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.6/julia-0.6-latest-win32.exe"
+  - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x86/julia-latest-win32.exe"
     PYTHONDIR: "use_conda"
     PYTHON: "use_conda"
 
-  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x64/0.6/julia-0.6-latest-win64.exe"
+  - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x64/julia-latest-win64.exe"
     PYTHONDIR: "use_conda"
     PYTHON: "use_conda"
 
+matrix:
+  allow_failures:
+    - channel: nightly
+
+
 branches:
   only:
     - master

src/SymPy.jl

@@ -5,8 +5,6 @@ __precompile__()
 
 module SymPy
 
-using Compat
-import Compat: @compat, invokelatest
 
 """
 
@@ -77,12 +75,8 @@ import Base: div
 import Base: trunc
 import Base: isinf, isnan
 import Base: real, imag
-import Base: expm
 import Base: nullspace
 
-if VERSION < v"0.6.0-dev"
-    import Base: factor, isprime
-end
 
 export sympy, sympy_meth, @sympy_str, object_meth, call_matrix_meth
 export Sym, @syms, @vars, symbols
@@ -115,7 +109,7 @@ export members, doc, _str
 ## Following PyPlot, we initialize our variables outside _init_
 const sympy  = PyCall.PyNULL()
 const mpmath = PyCall.PyNULL()
-
+const combinatorics  = PyCall.PyNULL()
 
 include("types.jl")
 include("utils.jl")
@@ -124,7 +118,6 @@ include("core.jl")
 include("logical.jl")
 include("math.jl")
 include("mpmath.jl")
-include("specialfuns.jl")
 include("solve.jl")
 include("dsolve.jl")
 include("subs.jl")
@@ -139,13 +132,14 @@ include("ntheory.jl")
 include("sets.jl")
 include("display.jl")
 include("lambdify.jl")
-include("physics.jl")
+include("call.jl")
+include("plot_recipes.jl") # hook into Plots
 
-## add call interface depends on version
-VERSION >= v"0.5.0-" && include("call.jl")
-v"0.4.0" <= VERSION < v"0.5.0-" && include("call-0.4.jl")
+## optional modules
+include("permutations.jl")
+include("physics.jl")
+include("specialfuns.jl")
 
-include("plot_recipes.jl") # hook into Plots
 
 ## create some methods
 
@@ -169,6 +163,8 @@ The SymPy documentation can be found through: http://docs.sympy.org/latest/searc
     end
 end
 
+
+    
 ## These are *added*, so exported
 for meth in union(core_sympy_methods,
                   math_sympy_methods,
@@ -182,6 +178,7 @@ for meth in union(core_sympy_methods,
                   logic_sympy_methods,
                   polynomial_sympy_methods,
                   ntheory_sympy_methods,
+                  combinatoric_sympy_methods,
                   solveset_sympy_methods
                   )
 
@@ -191,7 +188,7 @@ for meth in union(core_sympy_methods,
 `$($meth_name)`: a SymPy function.
 The SymPy documentation can be found through: http://docs.sympy.org/latest/search.html?q=$($meth_name)
 """ ->
-        ($meth){T<:SymbolicObject}(ex::T, args...; kwargs...) = sympy_meth($meth_name, ex, args...; kwargs...)
+        ($meth)(ex::T, args...; kwargs...) where {T<:SymbolicObject} = sympy_meth($meth_name, ex, args...; kwargs...)
 
     end
     eval(Expr(:export, meth))
@@ -239,7 +236,7 @@ for prop in union(core_object_properties,
                   polynomial_predicates)
 
     prop_name = string(prop)
-    @eval ($prop)(ex::Sym) = PyObject(ex)[@compat(Symbol($prop_name))]
+    @eval ($prop)(ex::SymbolicObject) = PyObject(ex)[Symbol($prop_name)]
     eval(Expr(:export, prop))
 end
 
@@ -279,18 +276,9 @@ end
 # sympy"integrate"(x^2, (x, 0, 1))
 # ```
 # """
-
-sympy_str_v0_5 = quote
 macro sympy_str(s)
     (args...; kwargs...) -> _sympy_str(Symbol(s), args...; kwargs...)
 end
-end
-sympy_str_v0_4 = quote
-macro sympy_str(s)
-    (args...) -> _sympy_str(Symbol(s), args...)
-end
-end    
-VERSION < v"0.5.0" ? eval(sympy_str_v0_4) : eval(sympy_str_v0_5)
 
 """
 
@@ -325,32 +313,43 @@ end
 
 
 global object_meth(object::SymbolicObject, meth, args...; kwargs...)  =  begin
-    call_sympy_fun(PyObject(object)[@compat(Symbol(meth))],  args...; kwargs...)
-
+    meth_or_prop = PyObject(object)[Symbol(meth)]
+    if isa(meth_or_prop, PyCall.PyObject)
+        call_sympy_fun(meth_or_prop,  args...; kwargs...) # method
+    else
+        meth_or_prop            # property
+    end
 end
 
-
-
+   
 ## For precompilation we must put PyCall instances in __init__:
 function __init__()
 
     ## Define sympy, mpmath, ...
     copy!(sympy, PyCall.pyimport_conda("sympy", "sympy"))
 
+ 
+
     ## mappings from PyObjects to types.
-    basictype = sympy["basic"]["Basic"]
-    pytype_mapping(basictype, Sym)
 
+    copy!(combinatorics, PyCall.pyimport_conda("sympy.combinatorics", "sympy"))
+    pytype_mapping(combinatorics["permutations"]["Permutation"], SymPermutation)
+    pytype_mapping(combinatorics["perm_groups"]["PermutationGroup"], SymPermutationGroup)    
     polytype = sympy["polys"]["polytools"]["Poly"]
     pytype_mapping(polytype, Sym)
 
     try
-        matrixtype = sympy["matrices"]["MatrixBase"]
-        pytype_mapping(matrixtype, Array{Sym})
-        pytype_mapping(sympy["Matrix"], Array{Sym})        
+        pytype_mapping(sympy["Matrix"], Array{Sym})
+        pytype_mapping(sympy["matrices"]["MatrixBase"], Array{Sym})
     catch e
     end
 
+
+    basictype = sympy["basic"]["Basic"]
+    pytype_mapping(basictype, Sym)
+    
+
+    
     ##
     init_logical()
     init_math()