CODEWITHSUNDEEP
arraysjulia
Julien
Julien

Reputation: 781

Remove a value in an array and decrease the size of it

I have an array filled with some values. After running this code:

array = zeros(10)

for i in 1:10
   array[i] = 2*i + 3
end

The array looks like:

10-element Array{Float64,1}:
  5.0
  7.0
  9.0
 11.0
 13.0
 15.0
 17.0
 19.0
 21.0
 23.0

I would like to obtain, for example, the following array by removing the third value:

9-element Array{Float64,1}:
      5.0
      7.0
     11.0
     13.0
     15.0
     17.0
     19.0
     21.0
     23.0

How to do that?

EDIT

If I have an array (and not a vector), like here:

a = [1 2 3 4 5]

1×5 Array{Int64,2}:
 1  2  3  4  5

The deleteat! proposed is not working:

a = deleteat!([1 2 3 4 5], 1)

ERROR: MethodError: no method matching deleteat!(::Array{Int64,2}, ::Int64)

You might have used a 2d row vector where a 1d column vector was required.
Note the difference between 1d column vector [1,2,3] and 2d row vector [1 2 3].
You can convert to a column vector with the vec() function.
Closest candidates are:
  deleteat!(::Array{T,1} where T, ::Integer) at array.jl:875
  deleteat!(::Array{T,1} where T, ::Any) at array.jl:913
  deleteat!(::BitArray{1}, ::Integer) at bitarray.jl:961

I don't want a column vector. I would want:

1×4 Array{Int64,2}:
 2  3  4  5

Is it possible ?

Upvotes: 1

Views: 1665

Answers (2)

ultima
ultima

Reputation: 36

Deleteat! is only defined for:

Fully implemented by:

Vector (a.k.a. 1-dimensional Array)
BitVector (a.k.a. 1-dimensional BitArray)

A Row Vector (2 Dimensions) won't work. But ... there is a workaround by this trick:

julia> deleteat!(a[1,:], 1)'   # mind the ' -> transposes it back to a row vector. 

1×4 RowVector{Int64,Array{Int64,1}}:
 2  3  4  5

Ofcourse this wouldn't work for an Array with 2 or more rows.

Upvotes: 1

phipsgabler
phipsgabler

Reputation: 20950

To make that clear: Vector{T} in Julia is just a synonym for Array{T, 1}, unless you're talking about something else... we call Arrays of all ranks arrays.

But this seems to be a Matlab-inherited misconception. In Julia, you construct a Matrix{T}, ie., an Array{T, 2}, by using spaces in the literal:

julia> a = [1 2 3 4 5]
1×5 Array{Int64,2}:
 1  2  3  4  5

Deleting from a matrix does not make sense in general, since you can't trivially "fix the shape" in a rectangular layout.

A Vector or Array{T, 1} can be written using commas:

julia> a = [1, 2, 3, 4, 5]
5-element Array{Int64,1}:
 1
 2
 3
 4
 5

And on this, deleteat! works:

julia> deleteat!(a, 1)
4-element Array{Int64,1}:
 2
 3
 4
 5

For completeness, there's also a third variant, the RowVector, which results of a transposition:

julia> a'
1×4 RowVector{Int64,Array{Int64,1}}:
 2  3  4  5

From this you also can't delete.

Upvotes: 3

Related Questions