ecounysis

function Epley(wt, reps) {
  return wt * ( 1 + reps / 30);
}

function Brzycki(wt, reps) {
  return wt * 36 / (37 -reps);
}

function Lander(wt, reps) {
  return 100 * wt / (101.3 - reps * 2.67123);

ecounysis

function fnAverage() {
  // Accepts any number of functions as its arguments.
  // Returns a function that averages all the argument functions.
  // Argument functions can accept args. In which case, just pass them into the
  // returned function at call time.
  // Resulting function will error if called with fewer args 
  // than required by function requiring the most args.
  /*
  
  // Example: 

ecounysis

Parsing CSS file with monadic parser in Clojure

Inspired by "Parsing CSS with Parsec".

Just quick notes and code that you can play with in REPL.

By @kachayev

0. Intro

ecounysis

(defn summarize 
  "Summarizes a data set. Groups data by result of groupingf applied to each
  member of coll. Applies summarizingf to each group."
  [groupingf summarizingf coll]
  (let [grouped (group-by groupingf coll)]
    (map #(list (first %) (summarizingf (second %))) grouped)))

(defn summarize-count
  [groupingf coll]
  (summarize groupingf count coll))

ecounysis

require 'net/https'
require 'uri'

# create a path to the file "C:\RailsInstaller\cacert.pem"
cacert_file = File.join(%w{c: RailsInstaller cacert.pem})

uri = URI.parse("https://curl.haxx.se/ca/cacert.pem")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

ecounysis

using System.ComponentModel;
using System.Collections.Generic;
using System.Threading;
using System;

namespace Ecounysis.DataProcessing
{

   // How to use this:
  //  1. create a subclass

ecounysis

open System


let printLines n = 
    for s = 1 to n do
        Console.WriteLine()
    n

let getInt x =
  let succ = Int32.TryParse(x)

ecounysis

module Parsing = 

  //type Char = string
  //type Str = string
  type Remaining = string
  type Result<'a> = Success of 'a * Remaining
                    | Failure

  type Parser<'a> = string -> Result<'a>
  

ecounysis

let divisors x =
  List.init (int (Math.Sqrt(float x))) (fun x -> x + 1)
  |> List.filter (fun y -> x % y = 0)
  |> List.map (fun y -> [y ; x / y])
  |> List.reduce (fun x y -> x @ y)
  |> List.sort

let isPrime x =
  List.length (divisors x) = 2

ecounysis

namespace Obfuscation
// very weak encryption
// uses a "one-time pad" that is used over and over
// http://en.wikipedia.org/wiki/One-time_pad


module Text = 

    type Operation =
            | Encryption