function hamming(s1, s2)
count(z -> z[1] != z[2], zip(s1,s2))
end
hamming("ssss", "sssd")
count(z -> z[1] != z[2], zip(s1,s2))
end
hamming("ssss", "sssd")
Hi all, I'm having some issue creating a Fixpoint type in Julia - which I'm attempting to have extend AbstractArray. Initially the project was created in Python, but now Julia I am having to overload so many functions (more than mentioned here). The project is open source so if anyone can take some time to assist/point me in a better direction I'd really appreciate it. If there is a better forum to elaborate on this problem please let me know. Thank you.
@talonmyburgh could you link to the project or explain more? Do you mean a fixed point as in an invariant point in mathematics?
No, I mean a fixed point type as in the binary representation of a real number. See this branch of my repo here. fixpoint.jl has my Fixpoint and complex Fixpoint (CFixpoint). There are some tests scripts and the one which fails is pfb_fixed_test.jl due to me not having sufficient getindex/setindex! functions albeit that I've declared two sorts in fixpoint.jl. Thanks @hasnep:matrix.org .
@talonmyburgh Have you looked at how FixedPointNumbers.jl works? Could you import it instead of writing your own, or is there some feature you need? In that case, could you extend their implementation? https://github.com/JuliaMath/FixedPointNumbers.jl
Ah yes, I recall that the reason I did not choose to use the FixedPointNumbers.jl package was that it was limited to Integer types (i.e. 8,16,32... bit Fixed Point numbers) whereas for my research I need a variable bit-width and fractional bit-width. Thanks for the suggestion however.
I would like to optimize something like that :
my_dict[key] = get(my_dict, key, 0) +1
my_dict[key] = get(my_dict, key, 0) +1
So I save a hash call or something like that.
IntegerD = ceil(FD)
FDGal = FD - IntegerD
print("FDGAL: ", FDGal)
print("\n")
hIdeal = (k) -> sinc.(k.-FDGal)
print("hIdeal: ", hIdeal)
print("\n")
hApprox = hIdeal(idxWindow)
print("hApprox: ", hApprox)
print("\n")
Sig_fd[indm,:] = filt.(hApprox,1,[zeros(1,abs(IntegerD)),Sig[1:end+IntegerD]])
@ochebotar The arguments of
zeros are the dimensions of the matrix, so they all need to be integers, the error message is telling you that the second argument is a float instead of an integer. The documentation for ceil says ceil(x) returns the nearest integral value of the same type as x that is greater than or equal to x. So unexpectedly, if you give ceil a float it will return a float. You can fix it by casting the value to an integer, like this: IntegerD = Int(ceil(FD)). Hopefully that was helpful!
3 replies
@ochebotar: Also, you can use
println() to get new lines instead of using print(x) and print("\n")
@ochebotar: It's difficult to know what's going wrong without knowing what flit, hApprox, IntegerD or Sig are. Try to narrow down which part of that line is causing the error by running each part separately, maybe start with
Sig[1:end+IntegerD] because that doesn't look right to me.
Does anyone know if it is possible to use Roots.find_zero in a CUDA kernel? Below fails:
using CUDA
using Roots
g(x) = (x-1)^2
function kernel(a)
i = threadIdx().x
a[i] = find_zero(g, 0)
return
end
a = CuArray([1,2,3])
@cuda threads=length(a) kernel(a)InvalidIRError: compiling kernel kernel(CuDeviceVector{Int64, 1}) resulted in invalid LLVM IR
Reason: unsupported dynamic function invocation (call to display(x) in Base.Multimedia at multimedia.jl:324)
Is there a way to do something like foo[size(foo) .÷ 2] = 0, where foo is a 2D array?
1 reply
and yes, that's what I was looking for
I guess that's because it's very rarely used, I think I've seen Stefan Karpinski say that he regrets that syntax
I'd guess most Julia users use an IDE that has a keyboard shortcut for commenting multiple lines
If you don't use it then you wouldn't think to document it early on
Particularly that of such a lofty and self-glorified project like Julia. Not to mention, with such adequate funding and participation
But you're absolutely right, it IS there
I'd say that documentation should strive to first document best-practices, less important stuff can go nearer the end
But yeah, the search in the Julia docs suuuuucks
Have you been using Julia for very long?
Hello!
My system load (a lot) of functions dynamically (julia source) on demmand. The time spent in compilation while running the first time is too much to be aceptable; most of the functions are reloaded the next time the system is run and used with same type of arguments.
I would like to load the precompiled internals just after the source is reloaded. As my system manage wich functions are loaded, it is good that the system itself manage the loading of the precompilation stuff (for the functions that has run/precompiled in the past).
Where should I start reading to find a way to do the same as precompilation of packages but under the control of my system/app while it is running?
Note that the code loading is dynamic and atomic (generatedwhile running the system in the past), not contained in a package.
My system load (a lot) of functions dynamically (julia source) on demmand. The time spent in compilation while running the first time is too much to be aceptable; most of the functions are reloaded the next time the system is run and used with same type of arguments.
I would like to load the precompiled internals just after the source is reloaded. As my system manage wich functions are loaded, it is good that the system itself manage the loading of the precompilation stuff (for the functions that has run/precompiled in the past).
Where should I start reading to find a way to do the same as precompilation of packages but under the control of my system/app while it is running?
Note that the code loading is dynamic and atomic (generatedwhile running the system in the past), not contained in a package.
even after
using AlgebraicDynamics.UWDDynam
based on this documentation: https://algebraicjulia.github.io/AlgebraicDynamics.jl/dev/api/#AlgebraicDynamics.UWDDynam.ContinuousResourceSharer
Am I doing something dumb, or is this something I should take up with the AlgebraicDynamics folks?
@djinnome: Hi, I'm able to use
ContinuousResourceSharer by running using AlgebraicDynamics.UWDDynam and then running UWDDynam.ContinuousResourceSharer. If you don't want to specify UWDDynam each time you can run const ContinuousResourceSharer = UWDDynam.ContinuousResourceSharer