MethodError with julia: cannot `convert` an object of type Matrix{ComplexF64}

I was working with Scilab and I decide to work with Julia however there are some errors which I didn't arrive to solve. For instance, I would like to fill out a vector using values of a given function but I got this error. Here is the code that I used:

using LinearAlgebra
A = [5/12 -1/12; 3/4 1/4];  c=[1/3;1]; b=[3/4; 1/4];
N = 10; T = 4; ts = (0:N)*T/N;
dt = T/N; λ = 10^(-14/(2*N+1));
m=length(c) ;
em0=b'/A # b^t * inv(A)
 em1 = 1 .-em0*ones(m,1)
 γ(z) =@. z/(1.0 -z*em1)
u_hat=complex(zeros(1,N+1));
u_hat[1]=γ(im)

The over-arching issue you are facing is that, coming from Scilab, you are probably not used to distinguishing scalars, vectors and matrices. Like in Matlab, Scilab scalars are really 1x1 matrices, and vectors are really Nx1 or 1xN matrices.

This is very different in Julia. A scalar is not the same as a 1x1 matrix, and a vector is not the same as a Nx1 matrix. You should therefore take care to distinguish them. In particular, you should avoid creating a matrix, zeros(M, 1), when what you really need is a vector, zeros(M).

The direct reason for the error message is that γ(im) is a matrix, because em1 is a matrix:

julia> γ(im)
1×1 Matrix{ComplexF64}:
 0.0 + 1.0im

u_hat is also a matrix of ComplexF64, and you are trying to assign a matrix as one of its elements, which naturally won't work, only scalar values can be elements of a Matrix{ComplexF64}.

I took the liberty of writing a cleaned up version of your code:

A = [5/12 -1/12; 3/4 1/4]
# use commas when defining vectors (this is just about style)
b = [3/4, 1/4]   
N = 10

## None of the below variables are used. Try to make your example minimal
c = [1/3, 1]  
T = 4
dt = T/N;
ts = (0:N) .* dt
λ = 10^(-14/(2*N+1))
m = length(c)
############### <- not used

# prefer vectors over 1xN or Nx1 matrices
em0 = A' \ b 

# dot product of a vector and a vector of ones is just a sum, but super-wasterful and slow.
em1 = 1 - sum(em0)

# don't use global variables(!!!), and remove the `@.`
γ(z, a) = z / (1 - z * a)

# use vectors, not 1xN matrices, and directly create a complex matrix instead of converting a real one.
û = zeros(ComplexF64, N+1)

# Now this works
û[1] = γ(im, em1)

I renamed u_hat to û for fun.

Also: remember to put your code in a function, always.

Just in the case of locating the root of the problem:
The problem is where you declared the em1 as em1 = 1 .-em0*ones(m,1). Since the output of the em0*ones(m,1) is expected to be a scalar, you can grasp it using the only function (I don't argue with your approach, and that's out of the interest of this answer):

julia> using LinearAlgebra

# Note that with this modification, there isn't any need for `@.` anymore.
julia> γ(z) = z/(1.0 -z*em1)
γ (generic function with 1 method)

julia> A = [5/12 -1/12; 3/4 1/4];  c=[1/3;1]; b=[3/4; 1/4];
       N = 10; T = 4; ts = (0:N)*T/N;
       dt = T/N; λ = 10^(-14/(2*N+1));
       m=length(c);
       em0=b'/A;

       #This is where the problem can be solved
       em1 = 1 - only(em0*ones(m,1));

       u_hat=complex(zeros(1,N+1));
       u_hat[1]=γ(im)
0.0 + 1.0im

julia> u_hat
1×11 Matrix{ComplexF64}:
 0.0+1.0im  0.0+0.0im  0.0+0.0im  0.0+0.0im  0.0+0.0im  …  0.0+0.0im  0.0+0.0im  0.0+0.0im  0.0+0.0im  0.0+0.0im