dakrone

;; This is proof-of-concept, it's not idiomatic and needs a lot of refactoring, take it with a block of salt.

(ns gradient-descent.core)


;; Thetas with starting values
(def theta0 (atom 1))
(def theta1 (atom 1))
(def theta2 (atom 1))

adamhjk

#!/usr/bin/env ruby

require 'rubygems'
require 'chef'
require 'chef/client'
require 'chef/run_context'

Chef::Config[:solo] = true
Chef::Config[:log_level] = :info
Chef::Log.level(:info)

kowey

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>WorkingDirectory</key>
	<string>/Users/kowey/kowey-wiki</string>
	<key>KeepAlive</key>
	<true/>
	<key>EnvironmentVariables</key>
	<dict>

debasishg

// joining of 2 arrows
(>>>) :: arr a b -> arr b c -> arr a c

         (>>>)
a -- (f) --> b -- (g) --> c

// works on pairs
// f: a -> b
// g: a -> c

yevgenko

!-------------------------------------------------------------------------------
! Xft settings
!-------------------------------------------------------------------------------

Xft.dpi:                    96
Xft.antialias:              false
Xft.rgba:                   rgb
Xft.hinting:                true
Xft.hintstyle:              hintslight

jonifreeman

import System.IO
import Control.Exception
import Numeric.LinearAlgebra
import Data.Digest.Pure.SHA
import Data.ByteString.Lazy.Char8 as BS8 (pack)
import Data.List (sort)
import System.Random (randomRIO)
import Network.Curl
import Text.Printf (printf)
import Data.List.Split (splitOn)

bdha

# It's important to convert the vbox image (VMDK or VDI or whatever) using
# the same version of VirtualBox that created it. You can try converting the image
# with qemu-img or kvm-img, but weird version mismatches will possibly make it not
# work.

# On your VirtualBox machine:

cd $VBOX_ROOT/$MACHINE_ROOT/
VBoxManage clonehd machine.vmdk machine.img --format RAW
scp machine.img root@kvm-host:/somewhere

rrnewton

> module Main where

How to write hybrid CPU/GPU programs with Haskell
-------------------------------------------------

What's better than programming a GPU with a high-level,
Haskell-embedded DSL (domain-specific-language)?  Well, perhaps
writing portable CPU/GPU programs that utilize both pieces of

jboner

Latency Comparison Numbers (~2012)
----------------------------------
L1 cache reference                           0.5 ns
Branch mispredict                            5   ns
L2 cache reference                           7   ns                      14x L1 cache
Mutex lock/unlock                           25   ns
Main memory reference                      100   ns                      20x L2 cache, 200x L1 cache
Compress 1K bytes with Zippy             3,000   ns        3 us
Send 1K bytes over 1 Gbps network       10,000   ns       10 us
Read 4K randomly from SSD*             150,000   ns      150 us          ~1GB/sec SSD

sseveran

-- | when no catch frame handles an exception dump core and terminate the process
uncaughtExceptionHandler :: SomeException -> IO () 
{-# NOINLINE uncaughtExceptionHandler #-}
uncaughtExceptionHandler !e = do
  syslog Error $ "Unhandled exception: " ++ show e
  raiseSignal sigABRT

setDefaultUncaughtExceptionHandler :: IO ()
setDefaultUncaughtExceptionHandler =
  setUncaughtExceptionHandler uncaughtExceptionHandler