Could not functions be used for this purpose?
Let us say you wish to get a constant array: How about you call a function
that will give you that array by CONSTRUCTING it on the fly. Since the
logic of the function is immutable, you get a constant array.
P
On Wednesday, February 18, 2015 at
Apparently it works fine (Thanks very much, Rob!).
Enjoy, and if you run into any trouble please feel free to let me know.
Petr
On Tuesday, February 17, 2015 at 12:20:22 PM UTC-8, Petr Krysl wrote:
Hi guys,
I have uploaded to Github a Julia package that wraps an automatic 2D
triangulation
Hi guys,
I have uploaded to Github a Julia package that wraps an automatic 2D
triangulation tool (binary). I only have access to Windows and Linux, so I
was wondering if anyone would be willing to take it for a spin on the Mac?
https://github.com/PetrKryslUCSD/Targe2.jl
Thanks!
Petr
Mauro,
I would be curious to learn details of what you did.
How did you define the reference solution? I presume it is the value of
the solution at some point in time?
Did you use extrapolation to the limit?
How did you measure the number of significant digits? In particular, for
the
Does anyone use sublime using a touch screen? I've tried to teach
sublime to select with a finger, but no luck so far.…
And, actually the same thing with the atom editor: I cannot with a
finger, it always results in the dragging of the entire pane.
Thanks,
Petr
On Monday, January
-and-conversion
Thanks,
Petr
On Sunday, January 11, 2015 at 12:20:39 PM UTC-8, Tobias Knopp wrote:
The call syntax is part of 0.4
Cheers
Tobi
Am Sonntag, 11. Januar 2015 19:35:06 UTC+1 schrieb Petr Krysl:
On Sunday, January 11, 2015 at 10:22:05 AM UTC-8, Tim Holy
Aha:
# Fast, got to declare the object!
function test5{T}(o::Type{T}, n)
summ=0
for i=1:n
summ=summ+o(i)
end
return summ
end
julia include(fun.jl)
test1(g, n) = 50023457750685
elapsed time: 0.619951473 seconds (480173520 bytes allocated, 27.32% gc
time)
test2(n) =
Thanks. Cool ideas!
P
On Thursday, January 15, 2015 at 12:08:05 PM UTC-8, Mauro wrote:
Have you read this recent thread and its examples?
https://groups.google.com/d/msg/julia-dev/JEiH96ofclY/_amm9Cah6YAJ
M
On Thu, 2015-01-15 at 20:50, Petr Krysl krysl...@gmail.com javascript:
wrote
So the call syntax on a type works, but using the implementation
referenced above, it is SLOW.
# Slow, function callback
function test1(f, n)
summ=0
for i=1:n
summ=summ+f(i)
end
return summ
end
g(i::Int)=i
# Fast, hardwired function g()
function test2(n)
summ=0
for i=1:n
Hi Tobias,
Is there an example of the use of this new syntax for 0.4?
Thanks,
Petr
On Sunday, January 11, 2015 at 12:20:39 PM UTC-8, Tobias Knopp wrote:
The call syntax is part of 0.4
Cheers
Tobi
Am Sonntag, 11. Januar 2015 19:35:06 UTC+1 schrieb Petr Krysl:
On Sunday, January 11
be a good
thing?
P
On Tuesday, January 13, 2015 at 4:06:30 PM UTC-8, Petr Krysl wrote:
Mauro,
On Tuesday, January 13, 2015 at 1:45:36 PM UTC-8, Mauro wrote:
I don't think it is good practice to add unrelated methods to generic
functions in Base. A guide-line could be to check whether your
Very true.
P
On Tuesday, January 13, 2015 at 6:17:30 PM UTC-8, ele...@gmail.com wrote:
On Wednesday, January 14, 2015 at 11:34:55 AM UTC+10, Petr Krysl wrote:
By the way: what is wrong with having
length(Boat)
length(Vacation)
length(Membership)
length(Stay)
length(Nose)
Hi Peter
I realized that one reason the discussion at
https://github.com/JuliaLang/julia/issues/4345
https://www.google.com/url?q=https%3A%2F%2Fgithub.com%2FJuliaLang%2Fjulia%2Fissues%2F4345sa=Dsntz=1usg=AFQjCNEVGpsg9UKLmRUDr3BN281cKXgCKA
was
not addressing my viewpoint was that there the issue is
I have a trouble following the reasoning in the 4345 issues trail.
If a module defines a method (let us say count) and brings in into an
environment that already has a method for the function count(), both are
available provided there signatures allow for the compiler to distinguish
between
I would argue that this would be prohibited by the compiler as it could not
distinguish between
foo(x::Number) = 2
and
foo(x::Float64) = 3
But, it would be perfectly safe to have
foo(a::TypeA)
and
foo(b::TypeB)
Different functions in that case.
In the example I gave, count was allowed to be
for generic function foo:
foo() at none:7
foo(x) at none:11
On Tue, 2015-01-13 at 17:22, Petr Krysl krysl...@gmail.com javascript:
wrote:
I have a trouble following the reasoning in the 4345 issues trail.
If a module defines a method (let us say count) and brings
Mauro,
On Tuesday, January 13, 2015 at 1:45:36 PM UTC-8, Mauro wrote:
I don't think it is good practice to add unrelated methods to generic
functions in Base. A guide-line could be to check whether your methods
matches up with the help text, if so, add it to Base.count otherwise
not.
I think I've had the same problem. I was given the advice of installing
the Anaconda distribution of python..
That worked.
Petr
On Tuesday, January 13, 2015 at 11:29:41 AM UTC-8, Manfred wrote:
As Julia user I am below novice level which is due to the fact that I
have not yet managed to
I have two nested modules, both of them export a function of the same name.
The functions have arguments of different types.
Both functions are also exported from the parent module. At least that is
the intent, but it fails.
Only the latest definition is visible outside (unqualified).
I'm not SURE, but the toolkit name (and the toolkit itself) is my
invention. First used in 2012.
This is not part of standard Matlab distribution
Petr
On Sunday, January 11, 2015 at 2:04:36 AM UTC-8, Milan Bouchet-Valat wrote:
Le samedi 10 janvier 2015 à 18:10 -0800, Petr Krysl
Sounds like a good idea.
P
On Saturday, January 10, 2015 at 7:23:25 PM UTC-8, Rob J Goedman wrote:
Petr,
Would you like me to prepare a simple pull request tomorrow?
Regards,
Rob
Sent from my iPhone
On Jan 10, 2015, at 6:22 PM, Petr Krysl krysl...@gmail.com
javascript: wrote
Here is a kludgy sort of solution. Tim and the other wizards will
probably know if it was suggested before.
https://gist.github.com/PetrKryslUCSD/7b96cd937e2e6cdb58db
Measurements:
elapsed time: 0.440441867 seconds (320050384 bytes allocated, 31.29% gc
time)
elapsed time: 0.001976364
On Sunday, January 11, 2015 at 10:22:05 AM UTC-8, Tim Holy wrote:
Already implement in julia 0.4.
Very cool! Just checking: are you saying that the solution I proposed
with the empty types would actually address the problem of functions
being inefficient as when passed in as
Regards,
Rob J. Goedman
goe...@mac.com javascript:
On Jan 11, 2015, at 9:30 AM, Petr Krysl krysl...@gmail.com javascript:
wrote:
Sounds like a good idea.
P
On Saturday, January 10, 2015 at 7:23:25 PM UTC-8, Rob J Goedman wrote:
Petr,
Would you like me to prepare a simple pull request
Hi,
I had a look at your package: very nice indeed! It is not clear to me
where the actual documentation is though. I followed some links to source
code and there was no documentation in there…
Petr
On Saturday, January 10, 2015 at 8:35:24 AM UTC-8, tshort wrote:
Docile.jl works great.
Jeff,
Not sure this is answering your question: both the commercial software and
the Julia solver were run on the same machine (i7 with 16 GB of memory
running Windows 7).
On an equivalent Linux laptop the Julia solver is even faster. Comsol is
not available on that laptop.
P
On Saturday,
The optimized toolkit JFinEALE is now available on github:
https://github.com/PetrKryslUCSD/JFinEALE
Petr
than I imagine.
Anyway, thanks for this great package! :)
Am Samstag, 10. Januar 2015 03:42:24 UTC+1 schrieb Petr Krysl:
Hello all,
Big thanks to Tim Holy and Andreas Noack. The FE solver implemented in
Julia as described previously (
https://groups.google.com/forum/?fromgroups
Correction: The repository has been now updated to look like a true Julia
package.
It can be cloned and there's even a rudimentary test.
https://github.com/PetrKryslUCSD/JFinEALE.jl
P
On Saturday, January 10, 2015 at 11:57:48 AM UTC-8, Petr Krysl wrote:
The optimized toolkit JFinEALE is now
Hello everybody,
I wonder if I could get some advice on how to structure a package? I could
see how the SRC and TEST folders had a place in the package structure,
but so far I could not discern a systematic way for access to examples that
use the package. In particular, when I create a
Hello all,
Big thanks to Tim Holy and Andreas Noack. The FE solver implemented in
Julia as described previously
(https://groups.google.com/forum/?fromgroups=#!searchin/julia-users/Krysl/julia-users/dgNqrJBZx5U/oGeXMZFjToMJ)
has been further optimized with their helpful hints and pointers.
hope I will remember from now on.
Thanks again,
Petr
On Friday, January 9, 2015 at 12:08:58 PM UTC-8, Tim Holy wrote:
On Friday, January 09, 2015 11:51:15 AM Petr Krysl wrote:
The size() function is from the base. fes.conn is a 2D array of ints.
No it's not, it's a JFIntMat
an indication if it is the case.
2015-01-09 14:51 GMT-05:00 Petr Krysl krysl...@gmail.com javascript::
The size() function is from the base. fes.conn is a 2D array of ints.
P
On Friday, January 9, 2015 at 11:25:34 AM UTC-8, Tim Holy wrote:
I wonder if your `size` function isn't returning
Actually, I realized that the example shows the same problem, but for a
different function. This time the allocation occurs in the function
CALLING getconn!.
P
On Friday, January 9, 2015 at 8:03:00 AM UTC-8, Petr Krysl wrote:
Tim,
Your explanation is very helpful
Tim,
Your explanation is very helpful. There is a complication though:
The function is actually called from another function (from a chain of
functions). Here is the measurement from a simplified situation:
- using JFFoundationModule
- using FESetModule
-
-
julia a=rand(100);
julia n=length(a);
julia @allocated for j=1:n
end
63983688
64 MB to run this loop? Is that expected?
Thanks for any insight.
Petr
-05:00 Petr Krysl krysl...@gmail.com javascript::
julia a=rand(100);
julia n=length(a);
julia @allocated for j=1:n
end
63983688
64 MB to run this loop? Is that expected?
Thanks for any insight.
Petr
to avoid performance gotchas in Julia.
Best regards,
P
Rob J. Goedman
goe...@mac.com javascript:
On Jan 6, 2015, at 6:39 PM, Petr Krysl krysl...@gmail.com javascript:
wrote:
Oh, in that case I am tickled pink.
Please do let me know if you find any typos or mistakes.
Best regards
Sorry, just noticed a typo. The second statement should read:
Parallel to the TIME axis is for all 0 = x = L for a fixed time, i.e.
initial conditions.
On Monday, January 5, 2015 8:48:04 PM UTC-8, Petr Krysl wrote:
Hi guys,
How does one figure out where allocation of memory occurs? When
Oh no, got that wrong. (Responding to email while rushing to class is not
a good idea.)
The FIRST statement was incorrect. Parallel to the TIME axis means w(0,t)
or w(L,t) for all t in range (i.e. between initial and final time).
Parallel to the space axis means w(0,t) or w(L,t) for all t in
What does this mean please?
function myfunction{f}(::Type{f}, args...)
# Do stuff using f just like an ordinary functionend
I'm sorry to have to ask this, it would be much better to just go to the
manual, but the manual search does not yield anything for Type{.
Thanks a lot,
Petr
, 2015 10:49:54 AM Milan Bouchet-Valat wrote:
Le lundi 05 janvier 2015 à 20:48 -0800, Petr Krysl a écrit :
Hi guys,
How does one figure out where allocation of memory occurs? When I
use the @time macro it tells me there's a lot of memory allocation
and deallocation going
Thanks very much. This is useful.
P
On Tuesday, January 6, 2015 1:50:11 AM UTC-8, Milan Bouchet-Valat wrote:
Le lundi 05 janvier 2015 à 20:48 -0800, Petr Krysl a écrit :
Hi guys,
How does one figure out where allocation of memory occurs? When I
use the @time macro it tells me
Actually, correction: for 0.3.4 the _system_ *.mem files are in the julia
folders. For _my_ source files the .mem files cannot be located.
P
On Tuesday, January 6, 2015 2:15:02 PM UTC-8, Petr Krysl wrote:
I did this as suggested. The code executed as shown below, preceded by
the command
**clear_malloc_data()*
*julia *
*include(/Users/rob/.julia/v0.3/FinealeBook/Examples/Fineale/Ch02/Ex07.jl)*
*shell **ls*
Ex07.jl Ex07.svg Ex08.svg Ex09.svg Section2.3.svg
Ex07.jl.mem Ex08.jl Ex09.jl Section2.3.jl Section2.4.nb
On Jan 6, 2015, at 2:15 PM, Petr Krysl krysl...@gmail.com javascript
lundi 05 janvier 2015 à 20:48 -0800, Petr Krysl a écrit :
Hi guys,
How does one figure out where allocation of memory occurs? When I
use the @time macro it tells me there's a lot of memory allocation
and deallocation going on. Just looking at the code I'm at a loss: I
can't see
JFinEALE.jl Poisson_FE_example_model.jl annulus_Q4_example.jl
Poisson_FE_Q4_example.jl Poisson_FE_example_model.jl.mem src
Poisson_FE_example.jl README.md tests
Robs-MacBook-Pro:jfineale_for_trying_out rob$
On Jan 6, 2015, at 3:01 PM, Petr Krysl krysl...@gmail.com javascript:
wrote:
Rob
, there may
be
some inaccuracies.
--Tim
On Tuesday, January 06, 2015 02:59:11 PM Petr Krysl wrote:
Actually, correction: for 0.3.4 the _system_ *.mem files are in the
julia
folders. For _my_ source files the .mem files cannot be located.
P
On Tuesday, January 6, 2015 2:15:02 PM
.
Regards,
Rob J. Goedman
goe...@mac.com javascript:
On Jan 6, 2015, at 3:01 PM, Petr Krysl krysl...@gmail.com javascript:
wrote:
Rob,
Thanks. I did find some .mem files (see above). Not for my own source
files though.
Petr
PS: You have a fineale book? Interesting... I thought no one
Hi guys,
How does one figure out where allocation of memory occurs? When I use
the @time macro it tells me there's a lot of memory allocation and
deallocation going on. Just looking at the code I'm at a loss: I can't see
the reasons for it there.
So, what are the tips and tricks for the
Here are two methods in two different modules:
julia methods(FEMMHeatDiffusionModule.distribloads)
# 1 method for generic function distribloads:
distribloads(self::FEMMHeatDiffusion,assembler,geom::NodalField{Float64},temp::N
odalField{Float64},fi::ForceIntensity{Float64},m::Int64) at
in FEMMHeatDiffusionModule and one
in FEMMAcousticsModule. Its the functions that clash. The issues suggests
that combining the functions is hard/risky/brittle/error prone and in
general a bad idea (tm).
Cheers
Lex
On Saturday, December 27, 2014 5:27:31 AM UTC+10, Petr Krysl wrote:
Here are two
, December 16, 2014 11:31:01 PM UTC-6, Petr Krysl wrote:
Hello everybody,
In case you're interested, here is the implementation so far. Switch to
the top folder, and include one of the examples.
If you have paraview, you could check the graphics output (enable
graphics export in the source
Great. Normally I have no use for Gauss rules beyond order 4 (at most cubic
finite elements in the library). But it is good to have access to arbitrary
order.
Thanks!
P
On Wednesday, December 17, 2014 1:35:34 PM UTC-8, Steven G. Johnson wrote:
In particular, it looks like you just need:
I have made some progress in my effort to gain insight into Julia
performance in finite element solvers.
I have compared my solver, J FinEALE, (compute and assemble global FE
matrices and vectors, then solve the sparse system with Julia's sparse
matrix facilities) with the commercial FEA
On Tuesday, 16 December 2014 17:52:29 UTC+1, Petr Krysl wrote:
I have made some progress in my effort to gain insight into Julia
performance in finite element solvers.
I have compared my solver, J FinEALE, (compute and assemble global FE
matrices and vectors, then solve the sparse system
Hello everybody,
In case you're interested, here is the implementation so far. Switch to
the top folder, and include one of the examples.
If you have paraview, you could check the graphics output (enable graphics
export in the source).
As always, I'm keen on getting feedback, so don't
Version 0.3.2+2 (2014-10-22 01:21 UTC)
release-0.3/6babc84* (fork: 180 commits, 126 days)
x86_64-w64-mingw32
w/o @profile 0.68 seconds
w @profile not finished 15 minutes later
Anyone else had this trouble?
Petr
Hello everybody,
I hope someone knows this: What is the use of writing
J[:,:] = K*M
where all of these quantities are matrices? I thought I'd seen somewhere
that it was assigning to the matrix in-place instead of creating a
temporary. Is that so?
I couldn't find it in the documentation
or mutation can occur. This is contrasted with
something like A_mul_B.
-- John
Sent from my iPhone
On Dec 14, 2014, at 7:48 PM, Petr Krysl krysl...@gmail.com
javascript: wrote:
Hello everybody,
I hope someone knows this: What is the use of writing
J[:,:] = K*M
where
the input J. However, they
will both allocate a new array.
If you want to avoid allocation, you'll have to use either A_mul_B!(C,A,B)
where C stores the result or BLAS.gemm!.
2014-12-14 20:12 GMT-05:00 Petr Krysl krysl...@gmail.com javascript::
???
Could I have that again please? I don't
Screen snapshot from 0.3:
| | |_| | | | (_| | | Version 0.3.2+2 (2014-10-22 01:21 UTC)
_/ |\__'_|_|_|\__'_| | release-0.3/6babc84* (fork: 180 commits, 127 days)
|__/ | x86_64-w64-mingw32
julia cd( C:/Users/pkrysl/Documents/Research/Software folder/FEA software
Naturally. I'm working on it. It is really more or less complete heat
conduction FE program, consisting of several modules. I will post the
whole thing on github.
Thanks for the info! It's become slightly more mysterious then...
Petr
On Saturday, December 13, 2014 9:48:42 AM UTC-8,
https://github.com/PetrKryslUCSD/Test_jfineale
The runner is Poisson_FE_example.jl.
I am running the test with
Version 0.3.2+2 (2014-10-22 01:21 UTC)
release-0.3/6babc84* (fork: 180 commits, 125 days)
x86_64-w64-mingw32
Petr
On Saturday, December 13, 2014 9:48:42 AM UTC-8, Steven G. Johnson
You're absolutely right, sorry! I got distracted and I forgot to post
instructions. I've also tried to simplify things, and I think I've gotten
it down to just a few lines of code. Unfortunately, the rest of the code
still needs to be there for declarations and such (
. If it is, the solver
uses the \(Diagonal, Matrix) method which avoid the LU factorization that
\(Matrix, Matrix) uses.
Do you think that is the reason?
2014-12-13 17:56 GMT-05:00 Petr Krysl krysl...@gmail.com javascript::
You're absolutely right, sorry! I got distracted and I forgot to post
, Tim Holy tim@gmail.com
javascript: wrote:
On Thursday, December 11, 2014 08:10:38 PM Petr Krysl wrote:
The moral of this story is: If you can't or won't declare every
single
variable, don't do loops. They are likely to be a losing proposition.
Just to follow up further
to be saying that the matrix returns the correct type. Am I
wrong?
Thanks,
Petr
On Friday, December 12, 2014 9:17:41 AM UTC-8, Petr Krysl wrote:
Stefan,
If you mean by the original code Ke1() and Ke2(), those were contrived
examples that unfortunately did not even represent the problems
Are perhaps matrices initialized as all zeros or identity matrices marked
as special behind the scenes, so that no actual processing is done when
there used for instance in multiplication?
Thanks,
Petr
Well, I can see no difference either.
But here is the tale of four matrices. They are each fed in turn to the
same operation as input: everything else is precisely the same. The timings
of that operation are as follows:
Rm1=eye(2,2) # 25 seconds
Rm2=[-0.668742918086684 -0.743493718540316;
Steven,
I also thought of floating-point exceptions. However, the results are
perfectly fine. Not identical, only within numerical precision, but pretty
good nonetheless.
The matrix passed in is the material of rotation matrix. Since the
material conductivity matrix is an identity, the
* element wise over the array.
No magic is going on there.
[1] https://github.com/JuliaLang/julia/issues/8450
[2] http://docs.julialang.org/en/release-0.3/stdlib/profile/
[3] https://github.com/lindahua/Devectorize.jl
On Thursday, 11 December 2014 06:23:29 UTC+1, Petr Krysl wrote:
Thanks. Now my
Acting upon the advice that replacing matrix-matrix multiplications in
vectorized form with loops would help with performance, I chopped out a
piece of code from my finite element solver
(https://gist.github.com/anonymous/4ec426096c02faa4354d) and ran some tests
with the following results:
the weird behavior of loops being slower than vectorized
code.
https://gist.github.com/PetrKryslUCSD/ae4a0f218fe50abe370f
Thanks again,
Petr
On Thursday, December 11, 2014 9:02:00 AM UTC-8, Andreas Noack wrote:
See the comment in the gist.
2014-12-11 11:47 GMT-05:00 Petr Krysl krysl...@gmail.com
One more note: I conjectured that perhaps the compiler was not able to
infer correctly the type of the matrices, so I hardwired (in the actual FE
code)
Jac = 1.0; gradN = gradNparams[j]/(J); # get rid of Rm for the moment
About 10% less memory used, runtime about the same. So, no effect
in column-major order
(same as Fortran) so that nested loops should arrange that the first
subscripts of multidimensional arrays are varied most rapidly.
--Peter
On Thursday, December 11, 2014 9:47:33 AM UTC-8, Petr Krysl wrote:
One more note: I conjectured that perhaps the compiler was not able
bytes allocated)
DeVectorized InBounds:
elapsed time: 0.032812311 seconds (128 bytes allocated)
Error norm deVec: 0.0
Error norm inBnd: 0.0
On Thursday, December 11, 2014 5:47:01 PM UTC+1, Petr Krysl wrote:
Acting upon the advice that replacing matrix-matrix multiplications in
vectorized form
Everybody:
Thank you very much for your advice. I believe that I have gotten the
loops working now.
The method conductivity(), 2 million triangles
With loops expanded: 25.294999069 seconds (5253831296 bytes
With matrix operations: 29.744513256 seconds (6564763296
So now the loops win by
John,
I hear you. I agree with you that type instability is not very helpful,
and indicates problems with program design.
However, I believe that provided the program cannot resolve the types
properly (as it couldn't in the original design of my program, because I
haven't provided
from the point of ambiguity.
-- John
On Dec 12, 2014, at 12:20 AM, Petr Krysl krysl...@gmail.com javascript:
wrote:
John,
I hear you. I agree with you that type instability is not very
helpful, and indicates problems with program design.
However, I believe
Well, temporary array was also on my mind. However, things are I believe
a little bit more complicated.
Here is the code with three timed options. As you can see, the first two
options are the fast one (multiplication with a scalar) and the slow one
(multiplication with a one by one
between 1 and 2 so HUUUGE?
I think this calls for someone who wrote the compiler. Guys?
Thanks a bunch,
P
On Wednesday, December 10, 2014 12:51:26 PM UTC-8, Petr Krysl wrote:
Actually: option (4) was also tested:
# 16.333766821 seconds (3008899660 bytes
fs[1]= f; fs *= (Jac * w[j
long
email chains.
--Tim
On Wednesday, December 10, 2014 02:35:38 PM Petr Krysl wrote:
I don't know if this is correct, but here is a guess:
Option 3 still requires a temp array ( to calculate the result of the
paren fs= ([f] * Jac * w[j]); ), and option 4 eliminates that temp
chains.
--Tim
On Wednesday, December 10, 2014 02:35:38 PM Petr Krysl wrote:
I don't know if this is correct, but here is a guess:
Option 3 still requires a temp array ( to calculate the result of the
paren fs= ([f] * Jac * w[j]); ), and option 4 eliminates that temp. The
cost
, December 10, 2014 07:54:00 PM Petr Krysl wrote:
The code is really short:
N=200
function doit1(N)
Fe=zeros(3,1);Ns=zeros(3,1)+1.0;f=-6.0;Jac=1.0;
for i=1:N
Fe += Ns * (f * Jac);
end
Fe
end
function doit2(N)
Fe
Thanks!
On Monday, December 8, 2014 2:09:27 AM UTC-8, Mauro wrote:
There was one talk about FEM at JuliaCon:
https://www.youtube.com/watch?v=8wx6apk3xQs
On Mon, 2014-12-08 at 04:48, Petr Krysl krysl...@gmail.com javascript:
wrote:
Bit more optimization:
Amuthan's code: 29
I posted a message yesterday about a simple port of fragments a finite
element code to solve the heat conduction equation. The Julia port was
compared to the original Matlab toolkit FinEALE and the Julia code
presented last year by Amuthan:
Hi Robert,
At this point I am really impressed with Julia. Consequently, I am tempted
to rewrite my Matlab toolkit FinEALE
(https://github.com/PetrKryslUCSD/FinEALE) in Julia and to implement
further research ideas in this new environment.
What did you have in mind?
Petr
pkr...@ucsd.edu
, THANKS!
Petr Krysl
Hello everybody,
I found Amuthan 's blog a while back, but only about two weeks ago I found
the time to look seriously at Julia. What I found was very encouraging.
For a variety of teaching and research purposes I maintain a Matlab FEA
toolkit called FinEALE. It is about 80,000 lines of
...@mac.com javascript:
On Dec 7, 2014, at 10:21 AM, Petr Krysl krysl...@gmail.com javascript:
wrote:
Hello everybody,
I found Amuthan 's blog a while back, but only about two weeks ago I found
the time to look seriously at Julia. What I found was very encouraging.
For a variety
Bit more optimization:
Amuthan's code: 29 seconds
J FinEALE: 54 seconds
Matlab FinEALE: 810 seconds
Petr
On Sunday, December 7, 2014 1:45:28 PM UTC-8, Petr Krysl wrote:
Sorry: minor correction. I mistakenly timed also output to a VTK file for
paraview postprocessing. This being an ASCII
When I qualify the names of functions or types within a module that I am
using with the name of the module, as for instance
fens1=FENodeSetModule.FENodeSet(xyz=[X[:,1] X[:,2]]),
I can access everything, even though the module does not export anything.
Is that as expected?
Thanks,
Petr
, 2014 5:34:32 PM UTC-6, Petr Krysl wrote:
When I qualify the names of functions or types within a module that I am
using with the name of the module, as for instance
fens1=FENodeSetModule.FENodeSet(xyz=[X[:,1] X[:,2]]),
I can access everything, even though the module does not export
I see, I missed the bit about the non-exported function p.
But that kind of worries me (am I the only one?). If I can get at
anything within a module, nothing is ever protected? I cannot have a
private function, shared only by the functions within the module?
In the same vein: there are no
Hello,
Does anyone know how the document functions and types (and modules) in the
Julia style?
I looked at the source code for some of the Base functions and I couldn't
really find any documentation attached to those functions.
Thanks,
Petr
Can I get the index vector from this function? This is what the Matlab
version does: it returns the sorted matrix and the permutation vector.
There doesn't seem to be a facility for this in Julia, unless I missed it
(possible).
Does anyone have a code that would do this?
By the way, I ran
this gets done, you can probably get the permutation by
concatenating a new column at the end, which is [1:m]. Then do sortrows on
this, and the last column should be the permutation vector.
-viral
On Friday, December 5, 2014 8:01:17 AM UTC+5:30, Petr Krysl wrote:
Can I get the index vector
Could you please explain where to find profile()? I run LT on Windows 7,
and there is no mention of profile view anywhere.
Thanks,
Petr
On Sunday, November 30, 2014 12:05:03 PM UTC-8, Valentin Churavy wrote:
So one argument feature wise for Juno/Lightable is the good integration of
Mike,
I'm not sure I use Juno /LT correctly, but I cannot run an example that
uses a module. The module file is in the workspace, but
control-shift-enter results in the message of
-
Error evaluating C:\Users\pkrysl\Documents\Research\Software folder\FEA
software
1 - 100 of 109 matches
Mail list logo
