Recently Vo Minh Thu wondered if Haskell (or, I generalize, functional
programming) can be of much use for computer graphics programming.
I'd like to point out a project that experimentally shown that
functional programming is of great help for processing of large raster
images (24-bit PPM
hello
i wonder if there are companies that use haskell in practice.
i'm a computer science student from switzerland (europe) and need to do an
internship. since i find haskell very interesting i thought these two things
could maybe be combined.
___
On 6/21/06, Andreas Kägi [EMAIL PROTECTED] wrote:
hello
i wonder if there are companies that use haskell in practice.
i'm a computer science student from switzerland (europe) and need to do an
internship. since i find haskell very interesting i thought these two things
could maybe be combined.
Hi
See section 7.1 in the latest HCAR at
http://haskell.org/communities/11-2005/html/report.html
Thanks
Neil
On 6/21/06, Andreas Kägi [EMAIL PROTECTED] wrote:
hello
i wonder if there are companies that use haskell in practice.
i'm a computer science student from switzerland (europe) and need
I think the issue wasn't using functional programming for large image
processing, it was using Haskell. OCaml is notoriously fast and
strict. Haskell/GHC is... lazy.
Everyone knows that laziness is supposed to be a virtue. In practice,
though, I'm one of the people who either can't wrap
Hello Joel,
Wednesday, June 21, 2006, 1:24:05 PM, you wrote:
I think the issue wasn't using functional programming for large image
processing, it was using Haskell. OCaml is notoriously fast and
strict. Haskell/GHC is... lazy.
+1 :)
Everyone knows that laziness is supposed to be a
Bulat Ziganshin wrote:
one possibly
interesting variant of these strict Haskell can be Clean language -
it's also lazy by default, afaik, but contains better features to
specify strictness, compiler that generates fast code (at the level of
OCaml/jhc), plus IDE with GUI libs. comparing to
Hello Jerzy,
Wednesday, June 21, 2006, 4:32:40 PM, you wrote:
one possibly
interesting variant of these strict Haskell can be Clean language -
it's also lazy by default, afaik, but contains better features to
specify strictness, compiler that generates fast code (at the level of
OCaml/jhc),
Hello,
I have installed ghc-6.4.2 on
a windows XP machine. However, the machine refuses to execute ghc-pkg (thus
preventing me from using Cabal) and complains that C:\ghc\ghc-6.4.2\bin\ghc-pkg.exe
is not a valid Win32 application. Is there something obvious
I might have overlooked while
I made a very simple matrix module that implements matrix sum and
multiplication.
It does not require any especific type since it uses Num [[a]]. So
instead of typing something like
Matrix [[1,0],[0,2]] * Matrix [[1,2],[3,4]]
you can just type
[[1,0],[0,2]]*[[1,2],[3,4]]
It needs
hi Bulat,
shortly :
with GPL you have to make your code GPL if it uses GPLed code.
with LGPL you dont have to make your code LGPL/GPL if it only links
against LGPLed library.
regards,
mt
2006/6/21, Bulat Ziganshin [EMAIL PROTECTED]:
Hello Jerzy,
Wednesday, June 21, 2006, 4:32:40 PM, you
fromInteger x = [[fromInteger x]]
Wouldn't you want the expression
[[1,0],[0,2]] + 10
to yield
[[11,10],[10,12]]
instead of [[11]] ? I guess you would need some complicated machinery
so this is one thing you have to ignore to keep your otherwise nifty
instance nice and simple.
Jared.
--
Sorry, a few corrections to my above points:
On 21/06/06, David House [EMAIL PROTECTED] wrote:
* Zipping the empty list with anything produces the empty list, so
your two equations for (*) involving the empty list are redundant.
I meant (+).
* You define vectorsum, but don't seem to use it
Hello Jeff,
Wednesday, June 21, 2006, 6:21:51 PM, you wrote:
I have installed ghc-6.4.2 on a windows XP machine. However, the
machine refuses to execute ghc-pkg (thus preventing me from using
Cabal) and complains that C:\ghc\ghc-6.4.2\bin\ghc-pkg.exe is not a
valid Win32 application. Is
Well, I was forcing A+[[]] to be A instead of [[]].
But who would do that kind of thing anyway?
So I agree with you, those 2 (+) lines are useless.
Atila
David House wrote:
Sorry, a few corrections to my above points:
On 21/06/06, David House [EMAIL PROTECTED] wrote:
* Zipping the empty list
Joel Reymont wrote:
I think the issue wasn't using functional programming for large image
processing, it was using Haskell. OCaml is notoriously fast and
strict. Haskell/GHC is... lazy.
Everyone knows that laziness is supposed to be a virtue. In practice,
though, I'm one of the people who
Am Mittwoch 21 Juni 2006 21:30 schrieb Brian Hulley:
Perhaps laziness is more foundational, in that you can write
if2 c x y = if c then x else y
However:
1) What's the advantage of being able to define if2?
Well, you can easily define you own control structures (when,
unless etc).
Hi,
I happen to like laziness, because it means that when I'm not thinking
about performance, I don't have to think about evaluation order _at
all_. And since my computer is a 750Mhz Athlon with Hugs, I never find
any need to worry about performance :) If it ever becomes an issue I
can move to
On Jun 21, 2006, at 3:30 PM, Brian Hulley wrote:
Joel Reymont wrote:
I think the issue wasn't using functional programming for large image
processing, it was using Haskell. OCaml is notoriously fast and
strict. Haskell/GHC is... lazy.
Everyone knows that laziness is supposed to be a virtue.
The (..) in the splice is out of scope according to GHC. If I use [||]
then it works, but for my purposes it's easier to use the constructors. How
should I refer to that variable?
import Data.Bits
import Language.Haskell.TH
main = print $ $(return $ VarE $ mkName ..) 7 (14 :: Int)
Jared Updike wrote:
Wouldn't you want the expression
[[1,0],[0,2]] + 10
to yield
[[11,10],[10,12]]
You could handle this as a special case in (+) and (*), but this is kind
of a hack. Something like:
(+) [[x]] y = map (map (x+)) y
(+) x [[y]] = map (map (+y)) x
(+) xy =
I dont see how to fix this.
There was a thread about statically knowing lots about the shape of
matrices using the type system.
http://www.haskell.org/pipermail/haskell/2006-April/017845.html
I believe they incorporated this (variable size identity matrix, for
example) in their approach.
Here is one way to do it. First, you have to interpret operations on
matrices as being elementwise applied. E.g, (*) is interpreted as zipWith
(zipWith (*)) rather than matrix multiply, and similar for (+) etc. You then
obtain a lazy semantics for the operations, where the extent of the
resulting
Instead of
fromInteger x = map repeat (repeat (fromInteger x))
I meant
fromInteger x = repeat (repeat (fromInteger x))
but it still doesn't work for multiplication.
Jared.
--
http://www.updike.org/~jared/
reverse )-:
___
Haskell-Cafe
I'm afraid the _meta_ programming aspect of the image processing
project may be overlooked.
Joel Reymont wrote:
I think the issue wasn't using functional programming for large image
processing, it was using Haskell. OCaml is notoriously fast and
strict. Haskell/GHC is... lazy.
Well, in
Usually once a year somebody starts a discussion on the merits of
functional/lazy paradigms, etc., in an applicative context, and it is
quite good. People compare Haskell and Ocaml, from time to time
somebody says that - apparently - Clean has better handling of strictness
issues [saying at the
[EMAIL PROTECTED] wrote:
[snip]
you may transform a recurrential equation yielding Y out of X:
Y[n+1] = a*X[N+1] + b*Y[n]
usually (imperatively) implemented as a loop, into a stream
definition:
filtr a b x@(x0:xq) = y where
y = (x0:yq)
yq = a*xq + b*y
Can you explain how this transformation
27 matches
Mail list logo
