Haskell Snippet – Summing Series #2

Just a little hack using show to make the earlier summing series example look a bit nicer.

Start with what I had before:

sumseries a b f = sum[f n|n<-[a..b]]

I have swapped around and renamed the arguments a little, just to tidy it up a tad.
Summing the first 5 evens (2 + 4 + 6 + 8 + 10):

*Main> sumseries 1 5 (\r -> 2*r)
30


So, I want to prettify it. I want to use Σ for the sum function. So this is easy, right? Just call the function Σ and be done with it. Not so – Sigma is an uppercase letter, and in haskell, these are reserved for datatypes.

Solution: make a datatype

data Σ a = Σ a a (a -> a)


Sure, we have a datatype, but we can’t call this. Now for the hack:

instance (Show a, Num a, Enum a) => Show (Σ a) where
show (Σ a b f) = show $ sumseries a b f

– when we want to show the datatype, like in ghci’s prompt, we call sumseries and show the result of that instead.

Example:

*Main> Σ 1 5 (\r -> 2*r)
30

or more concisely

*Main> Σ 1 5 (*2)
30


Deriving the Exponential Capacitor Decay equation

If you’ve studied capacitors, you’ll have (very probably) come across the decay equation:
where is resistance, is capacitance, is the charge on the capacitor at time and is the initial charge.

Where does this come from?

Firstly from the basics of circuits, we know that (yes, I’m using the british convention with regards the symbol for voltage, I understand elsewhere is used instead).

Now when we discharge a capacitor through a circuit, the e.m.f.s are supplied by the capacitor.

Now substitutiting for V in the above equation gives

So we now have an equation for the current in the circuit, but wait, where does this current come from? It’s the capacitor discharging – this current is equal to the rate of discharge of the capacitor, so:

So substituting the above expression for I

Ooh look, a differential equation.
Seperate the variables giving:

where k is some constant.

If we define the initial charge to be – the charge when t = 0

so we now can replace giving:

MY WORK HERE IS DONE

:D

A Browser in 14 Lines using Python and Webkit

I came across PyWebKitGtk and had to try it.
A browser, in 14 lines.

#!/usr/bin/env python

import gtk
import webkit
import gobject

gobject.threads_init()
win = gtk.Window()
bro = webkit.WebView()
bro.open("http://www.google.com")
win.add(bro)
win.show_all()

gtk.main()

And the obligatory screenshot:

A browser in 14 lines of python using webkit and gtk.

Blackboard and Chalk effect with Gimp

I changed my wordpress theme to something dark so want a new header – why not a blackboard :D

1. Create a new blank image – since the dimensions of the header are 760×200, I made it these dimensions
2. Fill the background with a dark greeny colour – I chose #0b1205
   

   I chose a dark-green colour

3. Go to filters->render->clouds->fog, set the colour to a light grey – I chose #d2c9b7 – and leave the other settings as they are (turbulence 1.0, opacity 100). This creates a new layer and renders some ‘fog’. Put the opacity of this layer to around 12.0
   

   I set the opacity to 12

4. Now for the text. Put some text on your blackboard with a whitish (#e7e7e7) font colour. Maybe try a slightly wavey font or one that imitates handwriting. I chose one of the Fell Types Fonts.
   

   A handwriting font may also look good.

5. Duplicate this layer. Now go to filters->map->warp. Leave almost everything as-is, but change the Dither Size to 1.0 (you may want to play around some more, but these settings seem to work).
   

   You could perhaps play around with these settings a bit more.

   
   The text should now look fairly chalky.
6. Lock the layer you just warped and select the other text layer – the one that hasn’t been warped. Put this below the warped layer. Choose filters->blur->motion blur. Choose Zoom. Set the centre of the blur to the right of your text and set the length to about 15.
   

   The result of the blur and the settings used to create this.

7. Set the opacity of this layer to about 15. Choose the smudge tool and a fairly large fuzzy brush. Smudge the layer about a bit.
   

   Just smudge it about a bit.

8. Make a new layer, call this border, and put it above all of the other layers. Choose select->all then select->shrink and enter the size of the border you want – I chose 12. Now choose select->invert and fill the resulting selection with a wood texture – I chose wood#1 but you could find a more exotic texture. Cancel the selection (select->none)
   

   Maybe not the most convincing wood texture, but it was there and I'm lazy.

9. Place guides at the edges of your border – i.e. for me this was at 12 and 188 vertically, 12 and 748 horizontally.
10. Make a new layer called shadow, and put it beneath your border layer. Make sure snap to guides is turned on (view->snap to guides). Select a fuzzy brush sized about 13 pixels. Set the brush colour to black. Now stroke along the top and left guides. I did this twice for both.
11. Make a new layer called highlight and put it beneath the shadow layer. Set the brush colour to white. Stroke along the right and bottom guides in the same way as before. This looks too bright, so set the opacity of this layer to about 6.
    

    Makes it look a bit more 3D.

12. All done!
    

    All done!

0.999… = 1

This morning Dream_Team brought up the age-old debate of whether

which of course it does.

Method 1

Although this seems fairly conclusive, there is a much nicer (IMO) way.

Method 2

One can treat the infintite decimal expansion as a geometric series.


Then it becomes apparent that the value of is equal to the sum to infinity of the geometric series.

And for a geometric series with common difference and first term
    for explanation see below
So for
Voilà.

This then prompted me to code some haskell, creating types for geometric and arithmetic series, but that post can come later.

Sum of Geometric Series

Now for the sum to infinity:

Game of life in APL

This almost makes me want to learn APL. Almost.

Script to print the name of the current desktop

Just a python script, to print the name of the current desktop. Could be useful to pipe to conky or something.

#!/usr/bin/env python
from Xlib import display, Xatom
dsp = display.Display()
rootwin = dsp.screen().root

DESKTOP_NAMES = dsp.intern_atom("_NET_DESKTOP_NAMES")
CURRENT_DESKTOP = dsp.intern_atom("_NET_CURRENT_DESKTOP")

def get_names():
    names = rootwin.get_full_property(DESKTOP_NAMES, 0)
    names = names.value.split("\x00")
    return names

def current_desktop():
    return rootwin.get_full_property(CURRENT_DESKTOP,
                                     Xatom.CARDINAL
                                     ).value[0]

try:
    print get_names()[current_desktop()]
except:
    print "error getting name"

Requires the python bindings for xlib

Down on the Farm – Charles Stross

This is a short story in Charles Stross’s “The Laundry” series, published on Tor.com

Read it online here
or download it as a pdf here (other formats found by clicking the download link on the left side)

Xlib Window Transparency

How to set the transparency opacity of a window with Xlib.

Set the _NET_WM_WINDOW_OPACITY property to an integer between 0x0 and 0xffffffff
An example function to set the opacity of a window using Xlib and python:

from Xlib import Xatom
def setOpacity(self, display, window, opacity):
        if 0.0 < = opacity <= 1.0:
            real_opacity = int(opacity * 0xffffffff)
            window.change_property(
                display.get_atom('_NET_WM_WINDOW_OPACITY'),
                Xatom.CARDINAL,
                32,
                [real_opacity,],
                )
        else:
            return

For this to work however, a composite manager of some kind must be running, but xcompmgr will suffice.

Free Charles Stross Audio-novella

I haven’t listened to it yet, but Charles Stross has to be one of my favourite authors, so it’s bound to be worth listening to. Get it here.

http://subterraneanpress.com/index.php/magazine/winter-2008/audio-trunk-and-disorderly-by-charles-stross/#