I just did some quick/simple plots in my module (calling PyQwt) and PyPlot
(calling matplotlib). The UI was a little more responsive with qwt, but I
couldn't see any major speed improvements, and I was able to zoom/pan in
both. In order to reduce fragmentation, I won't move this into a
It looks like you've implemented a lot. I'll take a look in more depth and
see how it fits in with my goals. I'm curious... is there a reason you
haven't merged in some way with StreamStats? It seems to overlap pretty
heavily, but maybe not. If it makes sense, are you open to collaboration
This is great... I haven't looked at StreamStats yet. It certainly seems like
the right package to extend. I'll start a discussion there. Thanks.
It's been several years since I used matplotlib actively, but I think I
switched to Qwt because its faster and better for panning/zooming. I don't
think its as feature-rich for publication-quality plots. I have used it
primarily for real time monitoring of financial time series and related
I'm considering writing packages for the following online (i.e. updating
models on the fly as new data arrives) techniques, but this functionality
might exist already, or there might be a package that I should contribute
to instead of writing my own:
- Online PCA (such as Candid
As part of a larger (private) codebase, I have a module that uses PyCall to
call into PyQwt5. I like Qwt a lot for fast, simple, interactive plotting.
I have a python wrapper that sets up zooming/panning functionality and
some other basics. The python code is mostly from another private
Agreed that gensym may be unnecessary. Do you really need access to all
those functions? If you redefine the same function every time, is that
faster?
On Tuesday, April 28, 2015 at 9:17:16 AM UTC-4, Yuuki Soho wrote:
The README.md is just the default page shown on github,
The reason is a little subtle, but it's because you have an abstract type
inside a parametric type, which confuses Julia. When you annotate
a::MyAbstractType, julia understands what to do with it (i.e. compiles
functions for each concrete subtype). When you annotate
+1 for factorize(MyType, ...), Sparse(MyDist, ...) and other similar
examples that have been suggested. It's only a very slight hardship for
those copying their code directly from matlab, but for everyone else I
think it's a big win for readability and type safety. It's also likely
easier to
I would check out PySide.jl. I'm not sure of the current package status,
but I have used Qt from both C++ and Python to do fairly intensive gui
work, and it's a very good framework. IMO, the only potential downside is
the license, but you'd have to evaluate that yourself.
On Tuesday, April
. apríla 2015 16:31:37 UTC+2 Tom Breloff napísal(-a):
The reason is a little subtle, but it's because you have an abstract type
inside a parametric type, which confuses Julia. When you annotate
a::MyAbstractType, julia understands what to do with it (i.e. compiles
functions for each
I too would like this feature. It's just one more way to throw errors as
soon as possible when appropriate. Could it be solved with parametric
Functions? Does anything like this exist already?
mufun(f::Function{Tuple{arg1Type, arg2Type}, returnType}, args...) = ...
On Wednesday, April 29,
Stefan: I agree that typing Distributions.Normal(0,1) in the REPL when
you're just doing data exploration is really frustrating. However, when
you're building a package or a larger system, it can be really important to
either explicitly qualify your types/functions or to explicitly import
Is this what you're looking for?
julia yyy(x::DataType) = true
yyy (generic function with 1 method)
julia yyy(x) = false
yyy (generic function with 2 methods)
julia yyy(Int)
true
julia yyy(5)
false
On Thursday, April 30, 2015 at 11:04:02 AM UTC-4, Tamas Papp wrote:
This is toy
Can you give us the definition of make_function as well? This is being run
in global scope?
On Monday, April 27, 2015 at 12:37:48 PM UTC-4, Antoine Messager wrote:
When I input the following code, where myfunction is only a system of 2
equations with 2 unknowns, the code starts to be really
I actually wonder if the bug is that Versions 1 and 4 *should* produce an
error, but they secretly work. In your version 1:
for i=1:2
if i=2; println(z); end
z=Hi
end
z should be local to each iteration of the loop, so I think the second pass
should produce an undefined error. See
Can anyone point me in the right direction of the files/functions in the
core library where dispatch is handled? I'd like to explore a little so I
can make comments that account for the relative ease at implementing some
of the changes suggested.
I agree that it would be really nice, in
I would consider contributing, since I 1) would like to use it, and 2) want
to learn more about integrating with C++. My problem is that I've never
seen or used Qt5 before, only Qt4. So I'd need someone else to take the
lead.
On Thursday, April 30, 2015 at 12:34:13 PM UTC-4, Max Suster
for the relative ease at implementing
some
of the changes suggested.
Start here:
https://github.com/JuliaLang/julia/blob/cd455af0e26370a8899c1d7b3d194aacd8c87e9e/src/gf.c#L1655
and this
https://www.youtube.com/watch?v=osdeT-tWjzk
On Thu, Apr 30, 2015 at 1:11 PM, Tom Breloff t
and I just don't know about it?
On Thursday, April 30, 2015 at 2:18:03 PM UTC-4, Matt Bauman wrote:
On Thursday, April 30, 2015 at 1:11:27 PM UTC-4, Tom Breloff wrote:
I agree that it would be really nice, in some cases, to auto-merge
function definitions between namespaces (database connects
at 11:39:20 PM UTC+10, Tom Breloff wrote:
I agree that auto-merging could cause hard-to-find bugs for the user.
This is less important than causing impossible-to-find bugs for a package
writer IMO.
I'm not sure I understand what impossible to find bug not merging
functions causes
I'm trying to understand if this is a feature or a bug. After using A,
if I immediately define f(x::Float64) then it silently masks the exported
method A.f(x). However if I call f(0) before trying to redefine it, then I
get a nice error. I feel like either:
1. The error is incorrect and
David and others: I created a new repo
(https://github.com/tbreloff/ModuleSafety.jl) where I'm going to play
around with some helper functions/macros to help with to safely use using
and module-local methods. If anyone wants to brainstorm on useful
functionality or contribute, please feel
This solves the problem because z is now local to g. I don't think it
gets at the heart of the issue though, which is the strangeness of z
seeming to have global scope (outside of the for loop) when inside the g()
definition, but the other z's have scope local to the for loop. Is that
I'm curious... what are the advantages of Qt5 over Qt4? Is there
functionality missing from Qt4?
On Wednesday, April 29, 2015 at 3:52:40 AM UTC-4, Steven Sagaert wrote:
I'd love to see a Qt5/QML wrapper. I find Qt5 superior to Gtk. Also it's
available on more platforms (mobile).
On
I think it's because when that for loop is compiled, it doesn't know for
certain that the if statement will be false in the first pass. I think
that's something that the compiler *could* know, but it takes a lot of
extra processing to prove those cases generically.
On Wednesday, April 29,
+1 John... everyone back to work! The core julia developers deserve a big
pat on the back for the *incredible* attention to detail and thoughtfulness
that has gone into designing the language. I've developed in a lot of
scientific and non-scientific languages, and julia constantly makes me
This may not be the most efficient, but is it what you were looking for?
A = ASCIIString[a,b,c,a,d,b]
u = Set(A)
B = ASCIIString[]
for a in A
if a in u
delete!(u,a)
else
push!(B,a)
end
end
# now B == [a,b]
On Wednesday, April 29, 2015 at 9:14:57 AM UTC-4, Ján Dolinský wrote:
Hi,
f*
* quote*
* function $f(y, fy)*
* $(lines...)*
* end*
* end*
* end*
Le lundi 27 avril 2015 18:12:24 UTC+1, Tom Breloff a écrit :
Can you give us the definition of make_function as well? This is being
run in global scope?
On Monday, April 27
It's pretty unrealistic to assume that a new language, developed by a small
group of developers located around the world, will have the consistency and
polish of a commercial language that has been in development for about 30
years with significant resources behind it. It's mind boggling how
Steven... can you post a summary of how you would ideally interact with
Qt5.jl? I assume you'd want clean syntax to define a gui with a QML string
(or file), along with clean syntax to define signals/slots to connect to
julia callbacks. Could you post some simple/hypothetical code that you
I agree that auto-merging could cause hard-to-find bugs for the user. This
is less important than causing impossible-to-find bugs for a package writer
IMO.
Here's a couple potential solutions for the user space issues:
- @verbose using SomeHugeModule
- this could analyze the exported
) = this is not a datatype
fun2{T}(x::T) = fun1(T,x)
type Foo end
fun2(Foo())
That said, I realized that DataType is not what I need.
Best,
Tamas
On Thu, Apr 30 2015, Tom Breloff t...@breloff.com javascript: wrote:
Is this what you're looking for?
julia yyy(x::DataType) = true
yyy
I agree with Stefan. The default behavior should be very conservative, and
any niceties (like merging) should be optional features/extensions. Thanks
David... I'll check this out.
On Monday, May 4, 2015 at 3:36:28 PM UTC-4, Stefan Karpinski wrote:
Cool. The fact that you can do this implies
Shashi: This looks really cool. And I'll be trying it out soon... thanks
for the effort.
On Monday, June 8, 2015 at 12:23:21 PM UTC-4, Shashi Gowda wrote:
Hello all!
I have been working on a package called *Escher* over the past several
months.
It is now quite feature-rich and ready to
I'm sure this won't work in every case, but depending on your usage you
could model after the hack at the beginning of this file:
https://github.com/joshday/OnlineStats.jl/blob/master/src/log.jl
On Saturday, June 6, 2015 at 4:46:44 AM UTC-4, Scott Jones wrote:
I have been trying to find out
I think you want to create a constructor:
TUnit(node::Float64,a::Float64,...,toff0::Float64) = TUnit(round(Int16,node
),a,...,toff0)
On Tuesday, June 9, 2015 at 10:50:06 AM UTC-4, Michela Di Lullo wrote:
My type is:
immutable TUnit
Node::Int16
a::Float64
b::Float64
I'm probably overlooking something simple, but is there a built-in function
to apply a function to each element of an abstract array without creating
a new array? This obviously only makes sense when you're updating an
object as part of the function call. Here's an example below... does this
See:
https://groups.google.com/forum/?hl=en#!topic/julia-users/emDJpY8UnL4
https://groups.google.com/forum/?hl=en#!topic/julia-users/CbInZXqs2d8
And look at the @p/@pipe macros in FunctionalData.jl and Pipe.jl
respectively. There's not a perfectly clean solution that I know of, so I
think it
:51 PM UTC-4, Tom Breloff wrote:
Stefan: Yes that's obviously valid. Simon's foreach is essentially
what I mean.
Although overriding the pipe operator would probably break things, I
think ideally there would be a built-in solution that looks similar to this:
julia |(A::AbstractArray, f
, ::Float64, ::Int64, ::Int16,
::Int16)*
* in anonymous at no file:5*
How could I specify that pt_l, attribute of the object TUnit, is a Matrix
and not a vector?
Thanks in advance for any suggestion,
Michela
Il giorno martedì 9 giugno 2015 18:54:56 UTC+2, Tom Breloff ha scritto
Array{MyType,1}:
MyType(2)
MyType(3)
MyType(4)
julia A
3-element Array{MyType,1}:
MyType(2)
MyType(3)
MyType(4)
On Tuesday, 9 June 2015 20:39:11 UTC+1, Tom Breloff wrote:
I'm probably overlooking something simple, but is there a built-in
function to apply a function to each
Stefan: Yes that's obviously valid. Simon's foreach is essentially what
I mean.
Although overriding the pipe operator would probably break things, I think
ideally there would be a built-in solution that looks similar to this:
julia |(A::AbstractArray, f::Function) = (for x in A; f(x); end;
I wonder if what we really need is just some extra additions to
Formatting.jl (since I think this is the best place to keep standard
formatting calls). We could add fmt2, fmt3, etc which would be meant for
formatting floats to that precision. I suspect that's the most common use
of
Will the language change? Yes. Will you have to relearn things? Yes. Will
new releases break code? Yes. Should you start using Julia now? YES!
The language is fairly mature, considering its age. I've been using Julia
exclusively for 8 months now. I used to do C/C++/Python/R and also
-users, I'm trying to
get in touch with Dahua Lin (author of Formatting.jl)
to see about adding a simpler `sfmt` that would help with this).
On Thursday, June 18, 2015 at 10:13:46 AM UTC-4, Tom Breloff wrote:
I wonder if what we really need is just some extra additions to
Formatting.jl (since
Yes it was on julia-dev. Regardless I think the right path forward is to
start a discussion on github (in Formatting.jl) and we could hash out
exactly what would be nice for users. Based on your posts, you may have a
very different perspective on string formatting that your average
Jones wrote:
Waiting for your comments, over at
https://github.com/lindahua/Formatting.jl/issues/8!
On Thursday, June 18, 2015 at 1:22:04 PM UTC-4, Tom Breloff wrote:
Yes it was on julia-dev. Regardless I think the right path forward is to
start a discussion on github (in Formatting.jl
How will Wednesday's hackathon be organized? I'm planning to arrive in the
afternoon, so I'd miss the morning session. Do people have projects in
mind?
If anyone is interested in Qt GUI development, we could work on my Qwt.jl
package! The goal is simple/clean creation of desktop GUIs
foreach. Of course, it goes without saying that
you ought to use whatever you find most helpful.
On Wednesday, June 10, 2015 at 10:48:27 AM UTC-4, Tom Breloff wrote:
I agree... using the pipe operator for this would be confusing at best,
and breaking at worst. However it would still be cool
Looks interesting. I'm wondering... can you give an example of the type of
problem this will help solve? I've been working with recurrent neural
networks, which seems to have some conceptual overlap with temporal graph
theory.
On Wednesday, June 10, 2015 at 12:12:52 PM UTC-4, Weijian Zhang
The obvious question... are you sure you're calling it with the expected
types? This should work:
julia powerE(x, Fs, Fc) = println(first definition)
powerE (generic function with 1 method)
julia powerE{T : FloatingPoint}(x::Array{T}, Fs::Integer, Fc::Integer) =
println(second definition)
You could create your own:
julia Base.readline(s, i::Int) = (for (j,line) in enumerate(eachline(s));
if j==i; return line; end; end; error(not enough lines))
readline (generic function with 4 methods)
julia f = open(/tmp/tmp.txt, w)
IOStream(file /tmp/tmp.txt)
julia for i in 1:20 write(f,
My gut reaction is that you don't want to use a macro here. Can you use a
parametric definition:
f{T}(vectype:T) = do something useful with the T
or can you just use multiple dispatch:
f{T:FloatingPoint}(v::Vector{T}) = something for floats
f{T:Integer}(v::Vector{T}) = something for ints
But it's so colorful!!
http://imgur.com/F7PqMMZ
On Wednesday, June 17, 2015 at 11:09:26 AM UTC-4, Nils Gudat wrote:
^ True, I assumed in my post above that the rows where the object of
interest here, just because it seems more natural to plot 10 1000 points
data series than 1000 data
{Float64,7}
pt_l::Matrix{Float64}
#pt_l::Array{Float64,2}
storia0UP::Float64
storia0DW::Float64
u0::Float64
ton0::Float64
toff0::Float64
#function foo(args)
##function body
#end
end
2015-06-10 16:36 GMT+02:00 Tom Breloff t
).
The advantage would be that you don't have to export the julia code that
you want to call from the GUI to Qt since the GUI is in julia.
The disadvantage is that you loose the ability to design the GUI
graphically via the design tool.
On Friday, May 1, 2015 at 2:58:06 PM UTC+2, Tom Breloff wrote
Has anyone used Escher/Compose/Gadfly for interactive
visualization/plotting with lots of data (million's of updates)? Is there
support for 3D visualization as part of this ecosystem? If not, is it
planned? Any performance gotchas I need to worry about? Bandwidth issues?
Missing
I think I've flipped my position back and forth 6 times in the last few
minutes while thinking about this. The mathematician in me wants those
special characters to be well defined operators with the expected
precedence, but the computer scientist in me thinks that's a horribly
stupid idea
That's great Rohit... looking forward to it! Keep us posted, and let me
know if there are areas you could use collaboration.
On Friday, July 3, 2015 at 9:35:16 AM UTC-4, Rohit Thankachan wrote:
On Thursday, 2 July 2015 20:04:20 UTC+5:30, Tom Breloff wrote:
*Compose3D*
I came across
Just curious... is there a reason simply checking for non-zero isn't
enough? Readability? Performance?
f(a,b,c) = (Bool(a) ? a * (b + c) : 0.0)
On Thursday, July 2, 2015 at 9:47:59 AM UTC-4, Jan Drugowitsch wrote:
Dear Julia users,
I am implementing an algorithm to solve a specific type
I can't comment on exactly why the return argument isn't inferred, but I'm
pretty sure that's a feature that is still actively being worked on by the
core devs. When you need to ensure the correct type from a comprehension,
you should be explicit:
...
mldBoot1 = Float64[ mean(sub(lD,
I'm interested in being able to do zero-copy concatenation of
AbstractArrays, with something similar to ArrayViews, but in reverse:
x = rand(4,2)
y = rand(4,2)
z = hcatview(x,y) # view that is able to index into hcat(x,y) without
creating the temporary matrix
x[1,1] = 10.0
@assert z[1,1] ==
supported,
I wonder how much work it would take to bridge that gap...
On Thursday, July 2, 2015 at 12:39:20 PM UTC-4, Jack Minardi wrote:
You could also look into calling out to Mayavi with PyCall.
On Wednesday, July 1, 2015 at 1:56:06 PM UTC-4, Tom Breloff wrote:
Has anyone used Escher/Compose
for
that!
On Monday, July 6, 2015 at 1:36:00 PM UTC-4, Scott Jones wrote:
That also sounds a lot like RopeStrings, although like the ChainedVectors,
it doesn't do multi-dimensional arrays, just vectors (strings).
On Friday, July 3, 2015 at 4:06:31 PM UTC-4, Tom Breloff wrote:
I'm interested in being
-reusable way... I'll post here if I think they could be
useful to anyone else. If anyone looks at Blox.jl and thinks I should NOT
abandon what I was doing, please let me know. :)
On Monday, July 6, 2015 at 2:02:04 PM UTC-4, Tim Holy wrote:
On Monday, July 06, 2015 10:59:48 AM Tom Breloff wrote
Didn't know this... thanks Avik. By the way, is there a summary somewhere
of the state of date/time functionality in Julia? It would be great to
know how the functionality compares between these and Calendar/Dates.
On Monday, July 6, 2015 at 6:09:45 PM UTC-4, Avik Sengupta wrote:
Good to
*when I said type-safe, I actually meant type-stable as Tim was discussing
On Monday, July 6, 2015 at 7:48:23 PM UTC-4, Tom Breloff wrote:
Yes for the general behavior I had in mind it would be nearly impossible
to keep the view constructor type-safe. For certain uses, that's less
Try:
map(x-x[1:min(length(x),15)], A)
On Thursday, July 2, 2015 at 3:06:33 PM UTC-4, paul analyst wrote:
How from dimensional array cut out no more than the first 15 characters of
each line, without loop. is posible it ?
I have :
julia A
3-element Array{Any,1}:
Lorem ipsum dolor sit
I haven't looked at the implementation yet, but this certainly seems
useful. @milktrader: does this belong in JuliaQuant?
On Sunday, July 5, 2015 at 11:55:07 PM UTC-4, felip...@gmail.com wrote:
Hello,
you might want to check out this new package I'm working on.
*Installation*
julia
I personally find underscores to be plenty good as private indicators.
Yes people may still reach in and access those fields directly, but I bet
they'll hesitate a little bit, which is all I ask. I certainly do NOT want
to force people to jump through extra hoops (boilerplate code), but
Sisyphuss: This is the approach I have taken with Qwt.jl:
`plot(rand(100,5))` will plot 5 lines, `plot(rand(100,2),
colors=[:red,:blue])` will plot 2 lines (red/blue), 'subplot(rand(100,4))`
will create a 2x2 grid of subplots, one for each column, etc.
This interface has nothing to do with
Thanks for the effort Ben. I'm curious... do you have any performance
comparisons of SimJulia vs other (simpler) code designs? How much speed
would I be giving up if I was using events in a tight inner loop?
On Tue, Aug 18, 2015 at 1:25 PM, Ben Lauwens ben.lauw...@gmail.com wrote:
Hi
based simulations.
I hope that I somehow answered your question. Please feel free to contact
me if you need some assistance with your SimJulia coding.
Ben
On Tuesday, August 18, 2015 at 9:52:21 PM UTC+2, Tom Breloff wrote:
Thanks for the effort Ben. I'm curious... do you have any performance
Looking forward to your ideas Amit. My experience with Go (and the all-in
recommendation to use channels for everything) is that very frequently this
is horribly bad advice. Channels will always be heavy weight due to the
fact that they have to maintain multiple states and context switch
I remember a post recently about improved performance when packing many
function arguments into an immutable for function calling. Is this
(jl_call1 vs jl_call) the reason?
On Tuesday, June 30, 2015 at 12:32:44 PM UTC-4, Isaiah wrote:
cool. you can go up to jl_call3. after that you need to
My gut reaction is that you should not even try to do this. Here's other
options:
# recommended
myrand() = rand() + 1
# if you really need to use rand
immutable MyUselessType end
Base.rand(::Type{MyUselessType}) = rand() + 1
What's your use case that you feel you need to do this? You get into
If anyone wants to follow, comment, or contribute:
https://github.com/tbreloff/Unums.jl
On Wed, Jul 29, 2015 at 12:01 PM, Job van der Zwan j.l.vanderz...@gmail.com
wrote:
Steven, have you read the book or are you basing your judgment on the
available presentations linked so far? Because you
The inexact exception flag isn't quite the same. That flag just signifies
that at some point in the calculation there was rounding. It doesn't give
any indication of how wrong the final number may be. The ubit coupled
with variable-sized unums allows for potentially very precise interval
Hi Joe. I take it you haven't gotten enough help on this forum? You could
post a more complete example of what you're trying to port, and also what
progress you've made. Github gists are a good way to put lots of code in
one place. It might be that you're missing a simple/key concept which
Job: I think you're on the right track. Given current hardware
optimizations, you might as well create a mostly fixed-length
specification, but with the advantages of truth that the ubit provides.
I'm thinking through an implementation that uses generated functions and
parameterized Unum types,
Then what kind of tribal language contest should it be??
On Thu, Jul 30, 2015 at 9:38 AM, Job van der Zwan j.l.vanderz...@gmail.com
wrote:
Let's not turn this into a tribal language pissing contest, please.
On Thursday, 30 July 2015 15:15:42 UTC+2, Tony Kelman wrote:
Hah. Go's definition
Simon: if I understand what you're suggesting, you'd like to add a
rounding direction flag whenever the ubit is set that would indicate
which direction you *would* round if you wanted to? I like this idea, as
it allows you to throw away the implicit open interval in favor of a
rounded exact value
.
On Thu, Jul 30, 2015 at 10:27 AM, Tom Breloff t...@breloff.com wrote:
Steven: There is a section in the book dedicated to writing dynamically
scaling precision/accuracy into your algorithms. The idea is this:
- Pick a small format unum at the start of your algorithm.
- During the algorithm, check
Steven: There is a section in the book dedicated to writing dynamically
scaling precision/accuracy into your algorithms. The idea is this:
- Pick a small format unum at the start of your algorithm.
- During the algorithm, check your unums for insufficient
precision/accuracy in the final
Just thinking out loud... I think it would be feasible to implement a
decimal unum, in which everything is essentially the same except it's
base 10. This may give a lot of benefits while still maintaining exact
numbers in many situations (But decimal intervals when inexact). Since
we're already
I added some info to the readme at https://github.com/tbreloff/Unums.jl. I
talk a little bit about how I'm intending to build the package, the
available types, etc. There is also a stub issue for continuing the
discussion of how unums fit into the world of numerical analysis:
Depending on your performance needs, you could make a copy constructor with
keyword arg overrides:
immutable Foo
x
y
end
Foo(foo::Foo; x=foo.x, y=foo.y)
foo1 = Foo(1, 2)
foo2 = Foo(foo1; y=5)
Note: this constructor could easily be written as a macro:
@copyconstruct immutable Foo
x
y
end
Thanks for the catch about the signbit... already changed.
On Fri, Jul 31, 2015 at 2:30 PM, John Gustafson johngustaf...@earthlink.net
wrote:
It would be wonderful if someone else would create a super-concise
explanation of unums! Thank you, thank you! I can't seem to do it. I must
be
To me, there are 3 main criteria that I'm comparing floats vs unums:
1) Speed
2) Elegance
3) Correctness
Right now Floats win #1 and Unums win #2 and #3 (IMO). If unums are
optimized in hardware someday, I believe they will also win #1, especially
with the addition of some summary bits that can
is far preferable to being very
precise but… wrong.
On Wednesday, July 29, 2015 at 8:14:43 AM UTC-7, Steven G. Johnson wrote:
On Wednesday, July 29, 2015 at 10:30:41 AM UTC-4, Tom Breloff wrote:
Correct me if I'm wrong, but (fixed-size) decimal floating-point has
most of the same issues
Heh... neither did I... I gave you code for column sums! Should be easy
enough to convert...
On Tue, Jul 28, 2015 at 12:05 PM, Stefan Karpinski ste...@karpinski.org
wrote:
Oh, didn't catch that you wanted row sums, but yeah, same basic idea.
On Tue, Jul 28, 2015 at 12:03 PM, Tom Breloff t
I would just write the loop explicitly:
julia function meanpositives(mat::Matrix)
nc = size(mat,2)
sums = zeros(nc)
counts = zeros(nc)
for c in 1:nc
for r in 1:size(mat,1)
v = mat[r,c]
if v 0
How about moving the discussion here:
https://github.com/tbreloff/Unums.jl/issues/2
On Thu, Jul 30, 2015 at 1:09 PM, Jeffrey Sarnoff jeffrey.sarn...@gmail.com
wrote:
+1 for grain of salt
On Saturday, July 25, 2015 at 9:11:54 AM UTC-4, Job van der Zwan wrote:
So I came across the concept of
indexing
and other niceties, but still allowing for arbitrary-precision intermediate
calcs, with exactness tracking.
On Wed, Jul 29, 2015 at 10:38 AM, Tom Breloff t...@breloff.com wrote:
Scott: Is your number format a public (open source) specification? How
does it differ from decimal floating
Correct me if I'm wrong, but (fixed-size) decimal floating-point has most
of the same issues as floating point in terms of accumulation of errors,
right? For certain cases, such as adding 2 prices together, I agree that
decimal floating point would work ($1.01 + $2.02 == $3.03), but for those
Scott: Is your number format a public (open source) specification? How
does it differ from decimal floating point?
On Wed, Jul 29, 2015 at 10:30 AM, Tom Breloff t...@breloff.com wrote:
Correct me if I'm wrong, but (fixed-size) decimal floating-point has most
of the same issues as floating
-4, Tom Breloff wrote:
Unums as a general concept seem really interesting. I ordered the book,
and may start a julia implementation (unless someone else gets there
first). Unified integer and floating point with clear accuracy information
could provide nice solutions for certain problems
I'm curious... Do you have any benchmarks of how much this can improve
performance?
On Saturday, August 8, 2015, vava...@uwaterloo.ca wrote:
I implemented a short macro that unrolls for-loops that have constant
bounds. For example
@unroll for i = 1 : 4
a[i] = b[i] + c[i] +
I have to disagree wholeheartedly that people should only learn the
language that they intend to use professionally. Ugh. You're a hobbyist and
just want to play around? Sure one language is fine. You're writing
derivatives pricing software? You had better well be an expert in software
design and
1 - 100 of 516 matches
Mail list logo
