sudipto80

//Average rating for all other rated items by the user
//except the item "except"
let rBaru(u:float list)(except:int)=
    let filtered = u |> List.mapi(fun i j -> if i <> except then j else 0.0)
                     |> List.filter(fun t -> t <> 0.0)
    float ( List.sum filtered ) / float filtered.Length

//The following function finds the common item indices
let commonItemIndices (ratings:(float list)list)(a:int)(u:int)=

sudipto80

let SimuDot (ratings :(float list)list) (a:int)(u:int)=
        let num =  List.zip ratings.[a] ratings.[u]
                       |> List.sumBy (fun item -> fst item * snd item)
        let d1 = ratings.[a] |> List.sumBy (fun item -> item  * item )
        let d2 = ratings.[u] |> List.sumBy (fun item -> item  * item )

        if d1 = 0.0 || d2 = 0.0 then 0.0 else num / (sqrt d1 * sqrt d2)

let ratings = [[4.;0.;5.;5.];[4.;2.;1.;0.];[3.;0.;2.;4.];[4.;4.;0.;0.];[2.;1.;3.;5.]]
SimuDot ratings 0 1

sudipto80

//Mean Absolute Error
let mae (ratings:float list)(predictions:float list) =
        (List.zip ratings predictions |> List.sumBy (fun t -> abs (fst t - snd t)))
                            /float ratings.Length

//Normalized Mean Absolute Error
let nmae (ratings:float list)(predictions:float list) =
   let rMax = ratings |> List.max
   let rMin = ratings |> List.min
   (mae ratings predictions )/(rMax - rMin)

sudipto80

//Calculates the standard deviation 
let stddev(list:float list)=
    sqrt (List.fold (fun acc elem -> acc + (float elem - List.average list) ** 2.0 ) 0.0
                     list / float list.Length)

let trueRanks = [1.;2.;3.;4.;5.;5.;7.;8.;9.;10.]
let predictedRanks = [1.;2.;3.;4.;6.;7.;5.;8.;10.;9.]
let uBar  =  trueRanks  |> List.average

let upBar = predictedRanks |> List.average

sudipto80

let sentence1 = "this is a a sample"
let sentence2 = "this is another another example example example"

let word = "example"
let numberOfDocs = 2.

let tf1 = sentence1.Split ' ' |> Array.filter ( fun t -> t = word) 
                              |> Array.length
let tf2 = sentence2.Split ' ' |> Array.filter ( fun t -> t = word)
                              |> Array.length

sudipto80

namespace IRLib



module asymSimilarity = 
    let private getABCD (first :string list)(second : string list) = 
        let all = Set.union (first |> Set.ofList) (second |> Set.ofList) |> Set.toList
        let firstMatches = all |> List.map (fun t -> first |> List.contains t )
        let secondMatches = all |> List.map (fun t ->  second |> List.contains t )

sudipto80

let biscuitA = ["refined wheat flour";"sugar";"edible vegetable oil";
                "edible coconut products";"invert syrup";"milk solids";
                "edible starch";"raising agent";"edible common salt";
                "baking powder";"solbake";"emulsifier"]

let biscuitB = ["refined wheat flour";"cocoa powder";"suger";"cocoa butter";
                "dextrose";"lecithin";"vanillin";"edible vegetable oil";
                "raising agent";"cocoa solids";"edible common salt";"emulsifier"]

let biscuitC = ["refined wheat flour";"suger";"cocoa solids";

sudipto80

open System.IO
let image = System.Drawing.Image.FromFile(@"C:\personal\rose.jpg")
let image2  = System.Drawing.Image.FromFile(@"C:\personal\potato.jpg")

let ms = new MemoryStream()
image.Save(ms,System.Drawing.Imaging.ImageFormat.Jpeg)
let bytes = ms.ToArray() |> Array.map int |> List.ofArray

let ms2 = new MemoryStream()
image2.Save(ms2,System.Drawing.Imaging.ImageFormat.Jpeg)

sudipto80

open System.IO
open System
open System.Windows.Forms
open System.Drawing

//The type that represents each row of the training 
//or the test dataset
type Entry = {Label :string; Values : int list}

//Calculates Squared Euclidean distance between pixel 

sudipto80

//Finds the median 
let median numbers = 
     let sorted =  List.sort numbers 
     let n = float numbers.Length 
     let x = int (n/2.)
     let mutable result = 0.0
     if (float numbers.Length) % 2. = 0.0 then result <- float (numbers.[x] + 
                                                     numbers.[x-1]) / 2.0
                                        else result <- float numbers.[x]
     result