Planet Open Ghana

Canonical · is

varioref
cleveref
\vref{fig:S3S4l}
\def\reftextfaceafter{}
\def\reftextfacebefore{}
\def\reftextcurrent{}
varioref
\unskip
\def\reftextfaceafter {\unskip}%
\def\reftextfacebefore{\unskip}%
\def\reftextcurrent   {\unskip}%
mathpazo
\linespread{1.05}
remreset
\makeatletter
\@removefromreset{figure}{chapter}
\renewcommand{\thefigure}{\arabic{figure}}
\@removefromreset{table}{chapter}
\renewcommand{\thetable}{\arabic{table}}
\makeatother
% Disable single lines at the start of a paragraph (Schusterjungen)
\clubpenalty = 10000
% Disable single lines at the end of a paragraph (Hurenkinder)
\widowpenalty = 10000 \displaywidowpenalty = 1000
\hline
\makeatletter
\def\stline{%
  \noalign{\vskip-.7em\vskip-\arrayrulewidth\hrule \@height \arrayrulewidth\vskip.7em}}
\makeatother
\KOMAoptions{twoside=false}
\begin{titlepage}
...
\end{titlepage}
\KOMAoptions{twoside=true}
\tableofcontents
{
\let\cleardoublepage\relax  % book
\let\clearpage\relax        % report
\let\chapter\section
\listofalgorithms
}
\chapter
hyperref
\texorpdfstring
\section{Stabilizer subgroups in \texorpdfstring{$\GL_r(\Z/2\Z)$}{GL\_r(Z/2Z)}}
\begin{tabbing}
\rule{4cm}{.4pt}\hspace{1cm} \= \rule{7cm}{.4pt} \\
Ort, Datum \> Unterschrift
\end{tabbing}
wine ghc --make
cabal install
$ rm *.o *.hi; ghc --make fourfours.hs ; time ./fourfours > /dev/null
[1 of 1] Compiling Main             ( fourfours.hs, fourfours.o )
Linking fourfours ...

real	0m1.909s
user	0m1.692s
sys	0m0.208s
$ rm *.o *.hi; wine ghc --make fourfours.hs ; time wine ./fourfours.exe > /dev/null
[1 of 1] Compiling Main             ( fourfours.hs, fourfours.o )
Linking fourfours.exe ...

real	0m1.631s
user	0m1.376s
sys	0m0.092s

$ rm *.o *.hi; ghc -O --make fourfours.hs ; time ./fourfours > /dev/null
[1 of 1] Compiling Main             ( fourfours.hs, fourfours.o )
Linking fourfours ...

real	0m0.981s
user	0m0.876s
sys	0m0.108s
$ rm *.o *.hi; wine ghc -O --make fourfours.hs ; time wine ./fourfours.exe > /dev/null
[1 of 1] Compiling Main             ( fourfours.hs, fourfours.o )
Linking fourfours.exe ...

real	0m1.270s
user	0m1.036s
sys	0m0.072s

arbtt-capture
~/.arbtt
.exe
categorize.cfg
arbtt-capture
arbtt-stats
PATH
arbtt-capture
arbtt-stats
tag Program:$current.program,
current window $title =~ m!(?:~|home/jojo)/projekte/(?:programming/(?:haskell/)?)?([^/)]*)!
  ==> tag Project:$1,
Usage: arbtt-stats [OPTIONS...]
  -h, -?       --help                 show this help
  -V           --version              show the version number
  -x TAG       --exclude=TAG          ignore samples containing this tag
  -o TAG       --only=TAG             only consider samples containing this tag
               --also-inactive        include samples with the tag "inactive"
  -m PERC      --min-percentage=PERC  do not show tags with a percentage lower than PERC% (default: 1)
  -i           --information          show general statistics about the data
  -t           --total-time           show total time for each tag
  -c CATEGORY  --category=CATEGORY    show statistics about category CATEGORY
arbtt-stats -o Program:evolution -c Evo-Folder -m 3
Statistics for category Evo-Folder
==================================
                         ||       Time Percentage
=========================++======================
      Evo-Folder:Eingang ||  22h20m00s      17.0%
     Evo-Folder:Bekannte ||  16h40m00s      12.7%
    Evo-Folder:d-haskell ||   9h40m00s       7.4%
       Evo-Folder:Itomig ||   8h20m00s       6.4%
   Evo-Folder:Verschickt ||   7h40m00s       5.8%
Evo-Folder:pkg-fso-maint ||   7h00m00s       5.3%
         Evo-Folder:Bugs ||   6h00m00s       4.6%
Evo-Folder:planet debian ||   4h00m00s       3.0%
    (60 entries omitted) ||   4h49m00s      36.7%
        (unmatched time) ||      8m00s       1.0%
VBoxManage controlvm VBoxMachineName keyboardputscancode 1D 38 3B 9D B8 CB 

VBoxManage controlvm VBoxMachineName keyboardputscancode 1D 38 3D 9D B8 CD
pub   4096R/F0FBF51F 2009-07-10
      Key fingerprint = 1A46 087F 955D 93C5 7C60  571B 3D90 8AB3 F0FB F51F
uid                  Joachim Breitner <mail@joachim-breitner.de>
uid                  Joachim Breitner <joachim.breitner@itomig.de>
uid                  Joachim Breitner (Jabber-ID) <nomeata@joachim-breitner.de>
uid                  Joachim Breitner <nomeata@debian.org>
sub   4096R/6F927969 2009-07-10
// This is the trivial plant, which just grows and grows
RULE "Very simple Rule"
GROW BY 1
RULE "Start"
WHEN Length <= 0
GROW BY 1
SET TAG = "Root1"

RULE "Story 1"
WHEN TAG = "Root1"
// No Percentage means 100%
BRANCH ANGLE = 70°, LENGTH = 2, Tag = ""
       ANGLE = -70°, LENGTH = 2, Tag = ""
       ANGLE = 0°, LENGTH = 1, TAG = "Root2"
SET TAG = ""

RULE "Story 2"
WHEN TAG = "Root2"
BRANCH AT 100% ANGLE = 70°, LENGTH = 1.5, Tag = ""
               ANGLE = -70°, LENGTH = 1.5, Tag = ""
               ANGLE = 0°, LENGTH = 1, TAG = "Root3"
SET TAG = ""

RULE "Story 3"
WHEN TAG = "Root3"
BRANCH AT 100% ANGLE = 70°, LENGTH = 1, Tag = ""
               ANGLE = -70°, LENGTH = 1, Tag = ""
               ANGLE = 0°, LENGTH = 1, TAG = "Root4"
SET TAG = ""

RULE "Story 4"
WHEN TAG = "Root4"
BRANCH AT 100% ANGLE = 70°, LENGTH = 0.5, Tag = ""
               ANGLE = -70°, LENGTH = 0.5, Tag = ""
               ANGLE = 0°, LENGTH = 0.5, Tag = "Tip"
SET TAG = ""

RULE "Star"
WHEN TAG = "Tip"
Blossom
data User = User {
	userName :: String,
	uses :: [Computer]
	}
data Computer = Computer {
	computerName :: String,
	owner :: User -- references the Users
	}
data State = State [User] [Computer]

testState = let user = User "Conrad" [computer]
                computer = Computer "Z3" user 
            in State [user] [computer]
data User = User {
	userId :: Int,
	userName :: String,
	uses :: [Int] -- references the Computers
	}
data Computer = Computer {
	computerId :: Int,
	computerName :: String,
	owner :: Int -- references the Users
	}
data State = State [User] [Computer]

testState = State
		[User 0 "Conrad" [1]]
		[Computer 1 "Z3" 0]
let State _ cs = testState in head cs
userId
ExplicitState
ExplicitUser
ExplicitComputer
ImplicitState
ExplicitState
ImplicitState
newtype Id v = Id v deriving (Show, Typeable, Data)
newtype Ref v = Ref Int deriving (Show, Typeable, Data)
data User ref = User {
	userId :: Int,
	uses :: [ref (Computer ref)]
	}
data Computer ref = Computer {
	computerId :: Int,
	owner :: ref (User ref)
	}
data State ref = State [User ref] [Computer ref]
Id
Ref
User Id
User Ref
Ref (User Ref)
(* -> *) -> *
Show
Id
Ref
StandaloneDeriving
deriving instance Show (User Id)
deriving instance Show (User Ref)
deriving instance Show (Computer Id)
deriving instance Show (Computer Ref)
deriving instance Show (State Id)
deriving instance Show (State Ref)
unrefState :: State Ref -> State Id
unrefUserRef :: State Id -> Ref (User Ref) -> Id (User Id)
unrefUserRef (State l _) (Ref i) = Id $ fromJust $
	find (\u@(User i' _) -> i == i') l 
unrefComputerRef :: State Id -> Ref (Computer Ref) -> Id (Computer Id)
unrefComputerRef (State _ l) (Ref i) = Id $ fromJust $
	find (\u@(Computer i' _) -> i == i') l 
unrefState
unrefState :: State Ref -> State Id
unrefState (State us cs) =
	let unrefState = State (map (unrefUser unrefState) us)
	                       (map (unrefComp unrefState) cs)
	in unrefState
  where unrefUser :: State Id -> User Ref -> User Id
        unrefUser s (User i refs) = User i (map (unrefComputerRef s) refs)

	unrefComp :: State Id -> Computer Ref -> Computer Id
	unrefComp s (Computer i ref) = Computer i (unrefUserRef s ref)
let
unrefUser :: State Ref -> User Ref -> User Id
unrefState
unrefSomething
gunref :: State Ref -> a Ref -> a Id
State Ref
User Ref
a
b
gunref :: (Data (a Id), Data (a Ref)) =>  State Ref -> a Ref -> a Id
Data
deriving instance Data (User Id)
deriving instance Data (User Ref)
deriving instance Data (Computer Id)
deriving instance Data (Computer Ref)
deriving instance Data (State Id)
deriving instance Data (State Ref
Typeable
Typeable
instance Typeable1 ref => Typeable (User ref) where
	typeOf _ = mkTyConApp (mkTyCon "User")     [typeOf1 (undefined :: ref ())]
instance Typeable1 ref => Typeable (Computer ref) where 
	typeOf _ = mkTyConApp (mkTyCon "Computer") [typeOf1 (undefined :: ref ())]
instance Typeable1 ref => Typeable (State ref) where 
	typeOf _ = mkTyConApp (mkTyCon "State")    [typeOf1 (undefined :: ref ())]
everywhere
Data.Generics
gfoldl
gunfold
Data.Dynamic
Data
data AData where AData :: Data a => a -> AData
instance Show AData where show (AData a) = "<" ++ show (typeOf a) ++ ">"

fromADataE :: forall b. Data b => AData -> b
fromADataE (AData d) = case cast d of
	Just v -> v
	Nothing -> error $ "Type error, trying to convert " ++
			   show (typeOf d) ++ " to  " ++
			   show (typeOf (undefined :: b)) ++ "."
AData
everywhere
type ADataT = AData -> Maybe AData

extADT :: forall a b. (Data a, Data b) => ADataT -> (a -> b) -> ADataT
extADT at t a@(AData v) = case cast v of 
		Just x ->  Just (AData (t x))
		Nothing -> at a

doNothing :: ADataT
doNothing = const Nothing
ADataT
doNothing
extADT
extT
everywhereADT :: forall a b. (Data a, Data b) => ADataT -> a -> b

-- first check if we can transform this value already
everywhereADT f v = case f (AData v) of
        -- if so, coerce it to the users’ requested type, which hopefully goes well
	Just r ->  fromADataE r 
	-- if not, we need to recurse into the data structure
	Nothing -> recursed

	-- for that, we first need to figure out the arguments to the 
        -- constructor. We store them in the untyped list
  where args :: [AData]
        (Const args) = gfoldl k z v
	-- gfoldl lets us have a look at each argument. We wrap it in AData
        -- and append it to the list
	k (Const args) arg = Const (AData arg : args)
	z start = Const []

	-- We need the data constructor of the input data type. If the user did not want
        -- it to be transformed, it will be the same
	c = toConstr v

	-- To give better error messages, we make sure that the outmost type constructor
        -- of the requested type actually has the data constructor we were given. Otherwise
        -- gunfold will complain in a non-helpful way
	input_type = dataTypeRep (constrType c)
	output_type = dataTypeRep (dataTypeOf (undefined :: b))

	recursed = if input_type /= output_type
                   then error $ "Can not convert <" ++ show input_type ++ ">"++
                                            " to <" ++ show output_type ++ ">."
	-- the types match, so we assemble the output type, using gunfold
                   else snd (gunfold k' z' c)
	k' :: forall b r . Data b => ([AData], b -> r) -> ([AData],r)

	-- we start by reversing the input list
	z' start = (reverse args,start)

	-- then we call us recursively on the argument and feed the result
        -- to the output constructor
	k' ((AData a) : args, append) = (args, append (everywhereADT f a))

-- Used for folding (we don’t need to retain the original constructor)
data Const a b = Const a 
bool2Int :: Bool -> Int
bool2Int False = 0
bool2Int True = 1

*Main> everywhereADT (doNothing `extADT` bool2Int) True :: Int
1
*Main> everywhereADT (doNothing `extADT` bool2Int) True :: ()
*** Exception: Type error, trying to convert Int to  ().
*Main> everywhereADT (doNothing `extADT` bool2Int) (True,False) :: (Int,Int)
(1,0)
*Main> everywhereADT (doNothing `extADT` bool2Int) ([True,False],True,()) :: ([Int],Int,())
([1,0],1,())
*Main> everywhereADT (doNothing `extADT` bool2Int) ([True,False],True,()) :: [()]
*** Exception: Can not convert  to .
*Main> everywhereADT (doNothing `extADT` bool2Int) [True] :: [Bool]
[*** Exception: Type error, trying to convert Int to  Bool.
gunref :: (Data (a Id), Data (a Ref)) =>  State Ref -> a Ref -> a Id
gunref s w = let unrefState = gunref' unrefState s
             in gunref' unrefState w

gunref' :: (Data (a Id), Data (a Ref)) =>  State Id -> a Ref -> a Id
gunref' unrefState = everywhereADT unref'
  where unref' = doNothing `extADT`
		 unrefUserRef unrefState `extADT`
		 unrefComputerRef unrefState
Ref
*Main> testState 
State [User {userId = 0, uses = [Ref 1]}] [Computer {computerId = 1, owner = Ref 0}]
*Main> gunref testState testState 
State [User {userId = 0, uses = [Id (Computer {computerId = 1, owner = Id (User {userId = 0,
uses = [Id (Computer {computerId = 1, owner = Id (User {userId = 0, uses = ..
{-# LANGUAGE DeriveDataTypeable, FlexibleInstances, GADTs,
             FlexibleContexts, StandaloneDeriving, ScopedTypeVariables #-}

		W	D	L	Points	Language	Code lines
1.	Kroschinsky	904	242	54	2954	Python	589
2.	Schulz	858	263	79	2837	Python	544
3.	Breitner	837	281	82	2792	Haskell	264
4.	Jackermeier	754	306	140	2568	Perl	183
5.	Roth	574	338	288	2060	C++	1731
6.	Eitel	567	355	278	2056	Ruby	352
7.	Reichel	342	328	530	1354	Python	266
8.	Zimmermann	303	400	497	1309	Java	1070
9.	Apensiv	190	353	657	923	Perl	410
10.	Maraun	150	300	750	750	C++	690
11.	Golemo	131	319	750	712	Python	104
12.	Ziegelwanger	120	337	743	697	C++	868
13.	Fuest	32	254	914	350	Python	645

Planet Open Ghana

Joachim Breitner: Talking at CeBIT tomorrow

Joachim Breitner: Teeth fashion

Joachim Breitner: Exploiting sharing in arbtt

Odzangba Dake: Optimize Your Internet Speed With Namebench DNS Benchmarking Tool

Odzangba Dake: How To Free Reserved Space On EXT4 Partitions

Joachim Breitner: Diploma Thesis Finished

Less chatty varioref

Palatino and extra leading

Counting figures independently from chapters

No widows and club lines

Struck table lines

Title page in one-sided layout

Not flushing the page for chapter heads

Math in headings vs. PDF bookmarks

Setting lines for the signature

Joachim Breitner: If I were a caricaturist

Joachim Breitner: FontForge-Article in the German Linux-Magazin

Joachim Breitner: pidgin-blinklight goes subliminal

Joachim Breitner: Serna XML editor uploaded to Debian

Joachim Breitner: DebConf mugshots view statistics

Joachim Breitner: screen-message ported to Windows

Joachim Breitner: Building arbtt for Windows

Joachim Breitner: Packaged unicode-screensaver properly

Joachim Breitner: Second Post!

Joachim Breitner: screen-message now in an online version

Joachim Breitner: arbtt now in Debian

Joachim Breitner: Parody Song: „College teacher“

George Gyau: Is been a long time

Joachim Breitner: Darcs Hacking Sprint: Mission Complete

Joachim Breitner: Arrived at the Darcs hacking sprint

Joachim Breitner: Maxi-Max-Algorithm

Joachim Breitner: Parody song „Another year at university“

Joachim Breitner: Releasing zpub as Free Software

Joachim Breitner: Mimesweeper

Joachim Breitner: About the Freedoms of Web Services

The Requirements

A) Availability of source code

B) Access to my data

C) Free data formats

D) An API

E) Choice of providers

F) Federation between providers

Analysis of a few services

e-mail

ICQ

Github/Gitorious

Facebook/StudiVZ

Twitter/identi.ca

OpenID

Conclusion

Odzangba Dake: How to Fix “subprocess pre-removal script returned error exit status 2″ Error

Odzangba Dake: How To Disable Compcache (and Fix Swap Errors) in Ubuntu 9.04

Joachim Breitner: arbtt: Now with Documentation

Kofi Boakye: The Global Village

Kofi Boakye: Karmic Kaola Goodness !!

Joachim Breitner: arbtt goes Binary

Kofi Boakye: From Gnome to KDE and back again

Joachim Breitner: Freaking out with LaTeX

Joachim Breitner: The Automatic Rule-Based Time Tracker

Odzangba Dake: Fix Dolphin Thumbnail Previews

Odzangba Dake: Using Google Talk With Kopete

Joachim Breitner: Already dead

Joachim Breitner: Ctrl-Alt-F1 in VirtualBox

Joachim Breitner: Stronger GPG key generated

Kofi Boakye: Back Again !!

Joachim Breitner: Introducing L-seed

The idea

The plant code

The gameplay

The game code

The call for help

Thanks

Joachim Breitner: Third place in AI programming contest

Joachim Breitner: Points of View

Odzangba Dake: Greetings from Ho

Joachim Breitner: Buzz free

Joachim Breitner: Bejeweled AI in Haskell

Odzangba Dake: GZIP vs. BZIP2 vs. LZMA

Joachim Breitner: Server updated to Lenny

`everywhere` is not enough