fixing #32

Author: sl-solution

docs/src/man/aggregation.md

@@ -30,7 +30,7 @@ julia> ds = Dataset(g = [1,2,1,2,1,2], x = 1:6)
    5 │        1         5
    6 │        2         6
 
-julia> combine(groupby(ds, :g), :x=>[sum, mean])
+julia> combine(groupby(ds, :g), :x=>[IMD.sum, mean])
 2×3 Dataset
  Row │ g         sum_x     mean_x   
      │ identity  identity  identity
@@ -39,7 +39,7 @@ julia> combine(groupby(ds, :g), :x=>[sum, mean])
    1 │        1         9       3.0
    2 │        2        12       4.0
 
-julia> combine(gatherby(ds, :g), :x => [maximum, minimum], 2:3 => byrow(-) => :range)
+julia> combine(gatherby(ds, :g), :x => [IMD.maximum, IMD.minimum], 2:3 => byrow(-) => :range)
 2×4 Dataset
  Row │ g         maximum_x  minimum_x  range    
      │ identity  identity   identity   identity
@@ -65,7 +65,7 @@ julia> ds = Dataset(rand(1:10, 10, 4), :auto)
    9 │        5        10         9         6
   10 │        1         1         3         4
 
-julia> combine(gatherby(ds, 1), r"x" => sum)
+julia> combine(gatherby(ds, 1), r"x" => IMD.sum)
 6×5 Dataset
  Row │ x1        sum_x1    sum_x2    sum_x3    sum_x4   
      │ identity  identity  identity  identity  identity
@@ -91,7 +91,7 @@ julia> ds = Dataset(g = [1,2,1,2,1,2], x = 1:6)
    5 │        1         5
    6 │        2         6
 
-julia> combine(gatherby(ds, :g), :x=>[maximum, minimum], 2:3=>byrow(-)=>:range, dropgroupcols = true)
+julia> combine(gatherby(ds, :g), :x=>[IMD.maximum, IMD.minimum], 2:3=>byrow(-)=>:range, dropgroupcols = true)
 2×3 Dataset
  Row │ maximum_x  minimum_x  range    
      │ identity   identity   identity

docs/src/man/grouping.md

@@ -194,7 +194,7 @@ Grouped by: g
    4 │        2   missing         3        2.3  missing          3.0
    5 │        2         2        -2       10.0  missing       -100.0
 
-julia> modify(ds, r"int" => x -> x .- maximum(x))
+julia> modify(ds, r"int" => x -> x .- IMD.maximum(x))
 5×6 Grouped Dataset with 2 groups
 Grouped by: g
  Row │ g         x1_int    x2_int    x1_float   x2_float   x3_float  
@@ -235,7 +235,7 @@ julia> setformat!(sale, :date=>year)
    5 │ 2014        132
    6 │ 2013        150
 
-julia> spct(x) = x ./ sum(x) .* 100
+julia> spct(x) = x ./ IMD.sum(x) .* 100
 spct (generic function with 1 method)
 
 julia> modify(groupby(sale, :date), :sale => spct => :sale_pct)

docs/src/man/missing.md

@@ -2,39 +2,37 @@
 
 ## Comparing data sets
 
-`==` of two data sets or two columns falls back to `isequal`.
+`==` of two data sets or two `DatasetColumn`s falls back to `isequal`.
 
 ## Every column supports `missing`
 
 The `Dataset()` constructor automatically converts each column of a data set to allow ‍‍‍‍‍`missing` when constructs a data set. All algorithms in InMemoryDatasets are optimised to minimised the overhead of supporting `missing` type.
 
 ## Functions which skip missing values
 
-When InMemoryDatasets loaded into a Julia session, the behaviour of the following functions will be changed in such a way that they will remove missing values if an `AbstractVector{Union{T, Missing}}` is passed as their argument. And it is the user responsibility to handle the situations where this is not desired.
-
-The following list summarises the details of how InMemoryDatasets removes/skips/ignores missing values (for the rest of this section `INTEGERS` refers to `{U/Int8, U/Int16, U/Int32, U/Int64}` and `FLOATS` refers to `{Float16, Float32, Float64}`):
-
-* `argmax` : For `INTEGERS`, `FLOATS`, `TimeType`, and `AbstractString` skip missing values. When all values are `missing`, it returns `missing`.
-* `argmin` : For `INTEGERS`, `FLOATS`, `TimeType`, and `AbstractString` skip missing values. When all values are `missing`, it returns `missing`.
-* `cummax` : For `INTEGERS`, `FLOATS`, and `TimeType` ignore missing values, however, by passing `missings = :skip` it jumps over missing values. When all values are `missing`, it returns the input.
-* `cummax!`: For `INTEGERS`, `FLOATS`, and `TimeType` ignore missing values, however, by passing `missings = :skip` it jumps over missing values. When all values are `missing`, it returns the input.
-* `cummin` : For `INTEGERS`, `FLOATS`, and `TimeType` ignore missing values, however, by passing `missings = :skip` it jumps over missing values. When all values are `missing`, it returns the input.
-* `cummin!`: For `INTEGERS`, `FLOATS`, and `TimeType` ignore missing values, however, by passing `missings = :skip` it jumps over missing values. When all values are `missing`, it returns the input.
-* `cumprod` : For `INTEGERS` and `FLOATS` ignore missing values, however, by passing `missings = :skip` it jumps over missing values. When all values are `missing`, it returns the input.
-* `cumprod!`: For `INTEGERS` and `FLOATS` ignore missing values, however, by passing `missings = :skip` it jumps over missing values. When all values are `missing`, it returns the input.
-* `cumsum` : For `INTEGERS` and `FLOATS` ignore missing values, however, by passing `missings = :skip` it jumps over missing values. When all values are `missing`, it returns the input.
-* `cumsum!` : For `INTEGERS` and `FLOATS` ignore missing values, however, by passing `missings = :skip` it jumps over missing values. When all values are `missing`, it returns the input.
-* `extrema` : For `INTEGERS`, `FLOATS`, and `TimeType` skip missing values. When all values are `missing`, it returns `(missing, missing)`.
-* `findmax` : For `INTEGERS`, `FLOATS`, `TimeType`, and `AbstractString` skip missing values. When all values are `missing`, it returns `(missing, missing)`.
-* `findmin` : For `INTEGERS`, `FLOATS`, `TimeType`, and `AbstractString` skip missing values. When all values are `missing`, it returns `(missing, missing)`.
-* `maximum` : For `INTEGERS`, `FLOATS`, `TimeType`, and `AbstractString` skip missing values. When all values are `missing`, it returns `missing`.
-* `mean` : For `INTEGERS` and `FLOATS` skip missing values. When all values are `missing`, it returns `missing`
-* `median` : For `INTEGERS` and `FLOATS` skip missing values. When all values are `missing`, it returns `missing`
-* `median!`  : For `INTEGERS` and `FLOATS` skip missing values. When all values are `missing`, it returns `missing`
-* `minimum` : For `INTEGERS`, `FLOATS`, `TimeType`, and `AbstractString` skip missing values. When all values are `missing`, it returns `missing`.
-* `std` : For `INTEGERS` and `FLOATS` skip missing values. When all values are `missing`, it returns `missing`
-* `sum` : For `INTEGERS` and `FLOATS` skip missing values. When all values are `missing`, it returns `missing`
-* `var` : For `INTEGERS` and `FLOATS` skip missing values. When all values are `missing`, it returns `missing`
+InMemoryDatasets has a set of functions which removes missing values. The following list summarises the details of how InMemoryDatasets removes/skips/ignores missing values (for the rest of this section `INTEGERS` refers to `{U/Int8, U/Int16, U/Int32, U/Int64}` and `FLOATS` refers to `{Float16, Float32, Float64}`):
+
+* `IMD.argmax` : For `INTEGERS`, `FLOATS`, `TimeType`, and `AbstractString` skip missing values. When all values are `missing`, it returns `missing`.
+* `IMD.argmin` : For `INTEGERS`, `FLOATS`, `TimeType`, and `AbstractString` skip missing values. When all values are `missing`, it returns `missing`.
+* `IMD.cummax` : For `INTEGERS`, `FLOATS`, and `TimeType` ignore missing values, however, by passing `missings = :skip` it jumps over missing values. When all values are `missing`, it returns the input.
+* `IMD.cummax!`: For `INTEGERS`, `FLOATS`, and `TimeType` ignore missing values, however, by passing `missings = :skip` it jumps over missing values. When all values are `missing`, it returns the input.
+* `IMD.cummin` : For `INTEGERS`, `FLOATS`, and `TimeType` ignore missing values, however, by passing `missings = :skip` it jumps over missing values. When all values are `missing`, it returns the input.
+* `IMD.cummin!`: For `INTEGERS`, `FLOATS`, and `TimeType` ignore missing values, however, by passing `missings = :skip` it jumps over missing values. When all values are `missing`, it returns the input.
+* `IMD.cumprod` : For `INTEGERS` and `FLOATS` ignore missing values, however, by passing `missings = :skip` it jumps over missing values. When all values are `missing`, it returns the input.
+* `IMD.cumprod!`: For `INTEGERS` and `FLOATS` ignore missing values, however, by passing `missings = :skip` it jumps over missing values. When all values are `missing`, it returns the input.
+* `IMD.cumsum` : For `INTEGERS` and `FLOATS` ignore missing values, however, by passing `missings = :skip` it jumps over missing values. When all values are `missing`, it returns the input.
+* `IMD.cumsum!` : For `INTEGERS` and `FLOATS` ignore missing values, however, by passing `missings = :skip` it jumps over missing values. When all values are `missing`, it returns the input.
+* `IMD.extrema` : For `INTEGERS`, `FLOATS`, and `TimeType` skip missing values. When all values are `missing`, it returns `(missing, missing)`.
+* `IMD.findmax` : For `INTEGERS`, `FLOATS`, `TimeType`, and `AbstractString` skip missing values. When all values are `missing`, it returns `(missing, missing)`.
+* `IMD.findmin` : For `INTEGERS`, `FLOATS`, `TimeType`, and `AbstractString` skip missing values. When all values are `missing`, it returns `(missing, missing)`.
+* `IMD.maximum` : For `INTEGERS`, `FLOATS`, `TimeType`, and `AbstractString` skip missing values. When all values are `missing`, it returns `missing`.
+* `IMD.mean` : For `INTEGERS` and `FLOATS` skip missing values. When all values are `missing`, it returns `missing`
+* `IMD.median` : For `INTEGERS` and `FLOATS` skip missing values. When all values are `missing`, it returns `missing`
+* `IMD.median!`  : For `INTEGERS` and `FLOATS` skip missing values. When all values are `missing`, it returns `missing`
+* `IMD.minimum` : For `INTEGERS`, `FLOATS`, `TimeType`, and `AbstractString` skip missing values. When all values are `missing`, it returns `missing`.
+* `IMD.std` : For `INTEGERS` and `FLOATS` skip missing values. When all values are `missing`, it returns `missing`
+* `IMD.sum` : For `INTEGERS` and `FLOATS` skip missing values. When all values are `missing`, it returns `missing`
+* `IMD.var` : For `INTEGERS` and `FLOATS` skip missing values. When all values are `missing`, it returns `missing`
 
 ```jldoctest
 julia> x = [1,1,missing]
@@ -43,43 +41,43 @@ julia> x = [1,1,missing]
  1
   missing
 
-julia> sum(x)
+julia> IMD.sum(x)
 2
 
-julia> mean(x)
+julia> IMD.mean(x)
 1.0
 
-julia> maximum(x)
+julia> IMD.maximum(x)
 1
 
-julia> minimum(x)
+julia> IMD.minimum(x)
 1
 
-julia> findmax(x)
+julia> IMD.findmax(x)
 (1, 1)
 
-julia> findmin(x)
+julia> IMD.findmin(x)
 (1, 1)
 
-julia> cumsum(x)
+julia> IMD.cumsum(x)
 3-element Vector{Union{Missing, Int64}}:
  1
  2
  2
 
-julia> cumsum(x, missings = :skip)
+julia> IMD.cumsum(x, missings = :skip)
 3-element Vector{Union{Missing, Int64}}:
  1
  2
   missing
 
-julia> cumprod(x, missings = :skip)
+julia> IMD.cumprod(x, missings = :skip)
 3-element Vector{Union{Missing, Int64}}:
  1
  1
   missing
 
-julia> median(x)
+julia> IMD.median(x)
 1.0
 ```
 
@@ -88,10 +86,10 @@ julia> median(x)
 `var` and `std` will return `missing` when `dof = true` and an `AbstractVector{Union{T, Missing}}` of length one is passed as their argument. This is different from the behaviour of these functions defined in the `Statistics` package.
 
 ```jldoctest
-julia> var(Union{Missing, Int}[1])
+julia> IMD.var(Union{Missing, Int}[1])
 missing
 
-julia> std(Union{Missing, Int}[1])
+julia> IMD.std(Union{Missing, Int}[1])
 missing
 
 julia> var([1]) # fallback to Statistics.var
@@ -103,7 +101,7 @@ NaN
 
 ## Multithreaded functions
 
-The `sum`, `minimum`, and `maximum` functions also support the `threads` keyword argument. When it is set to `true`, they exploit all cores for calculation.
+The `IMD.sum`, `IMD.minimum`, and `IMD.maximum` functions also support the `threads` keyword argument. When it is set to `true`, they exploit all cores for calculation.
 
 ## Other functions
 

docs/src/man/modify.md

@@ -57,7 +57,7 @@ julia> ds = Dataset(x1 = 1:5, x2 = [-2, -1, missing, 1, 2],
    4 │        4         1   missing
    5 │        5         2       0.4
 
-julia> modify!(ds, 2:3 => sum)
+julia> modify!(ds, 2:3 => IMD.sum)
 5×3 Dataset
  Row │ x1        x2        x3       
      │ identity  identity  identity
@@ -69,7 +69,7 @@ julia> modify!(ds, 2:3 => sum)
    4 │        4         0       0.7
    5 │        5         0       0.7
 
-julia> modify!(ds, :x1 => x -> x .- mean(x))
+julia> modify!(ds, :x1 => x -> x .- IMD.mean(x))
 5×3 Dataset
  Row │ x1        x2        x3       
      │ identity  identity  identity

docs/src/man/transpose.md

@@ -494,7 +494,7 @@ julia> ds = Dataset(A = ["foo", "foo", "foo", "foo", "foo",
    9 │ bar       two       large            7         9
 
 julia> ; # This first example aggregates values by taking the sum.
-julia> _tmp = combine(groupby(ds, 1:3), 4=>sum);
+julia> _tmp = combine(groupby(ds, 1:3), 4=>IMD.sum);
 
 julia> transpose(gatherby(_tmp, 1:2, isgathered = true), :sum_D, id = :C, variable_name = nothing)
 4×4 Dataset
@@ -530,7 +530,7 @@ julia> combine(groupby(ds, [:A, :C]), [:D, :E] => mean)
    3 │ foo       large      2.0       4.5
    4 │ foo       small      2.33333   4.33333
 
-julia> combine(groupby(ds, [:A, :C]), :D => mean, :E => [minimum, maximum, mean])
+julia> combine(groupby(ds, [:A, :C]), :D => mean, :E => [IMD.minimum, IMD.maximum, mean])
 4×6 Dataset
  Row │ A         C         mean_D    minimum_E  maximum_E  mean_E   
      │ identity  identity  identity  identity   identity   identity

docs/src/man/tutorial.md

@@ -245,13 +245,13 @@ julia> combine(groupby(flights, :Dest), :ArrDelay => mean)
                100 rows omitted
 ```
 
-we can summarise several columns at the same time, e.g. for each carrier, calculate the minimum and maximum arrival and departure delays:(Note that in the following code, `r"Delay" => [minimum, maximum]` is normalised as `names(flights, r"Delay") .=> Ref([minimum, maximum])`)
+we can summarise several columns at the same time, e.g. for each carrier, calculate the minimum and maximum arrival and departure delays:(Note that in the following code, `r"Delay" => [IMD.minimum, IMD.maximum]` is normalised as `names(flights, r"Delay") .=> Ref([IMD.minimum, IMD.maximum])`)
 
 
 ```julia
 julia> @chain flights begin
            groupby(:IATA)
-           combine(r"Delay" => [minimum, maximum])
+           combine(r"Delay" => [IMD.minimum, IMD.maximum])
         end
 14×5 Dataset
  Row │ IATA      minimum_DepDelay  maximum_DepDelay  minimum_ArrDelay  maximum_ArrDelay