require 'daru/view'

# Set a default plotting library
Daru::View.plotting_library = :nyaplot

df = Daru::DataFrame.new({
  a: Array.new(100) {|i| i}, 
  b: 100.times.map{rand}
})

scatter_1 = Daru::View::Plot.new(df, type: :scatter, x: :a, y: :b)

scatter_1.show_in_iruby

# DataFrame denoting Ice Cream sales of a particular food chain in a city
# according to the maximum recorded temperature in that city. It also lists
# the staff strength present in each city.

df = Daru::DataFrame.new({
  :temperature => [30.4, 23.5, 44.5, 20.3, 34, 24, 31.45, 28.34, 37, 24],
  :sales       => [350, 150, 500, 200, 480, 250, 330, 400, 420, 560],
  :city        => ['Pune', 'Delhi']*5,
  :staff       => [15,20]*5
  })
df

# Generating a scatter plot with tool tips, colours and different shapes.
scatter_2 = Daru::View::Plot.new(df, type: :scatter, x: :temperature, y: :sales).chart
scatter_2.tap do |plot, diagram|
  plot.x_label "Temperature"
  plot.y_label "Sales"
  plot.yrange [100, 600]
  plot.xrange [15, 50]
  plot.diagrams[0].tooltip_contents([:city, :staff])
  plot.diagrams[0].color(Nyaplot::Colors.qual) # set the color scheme for this diagram. See Nyaplot::Colors for more info.
  plot.diagrams[0].fill_by(:city) # Change color of each point WRT to the city that it belongs to.
  plot.diagrams[0].shape_by(:city) # Shape each point WRT to the city that it belongs to.
end

# Move the mouse pointer over the points to see the tool tips.

# Array of diagrams
scatter_2.diagrams

# A Bar Graph denoting the age at which various Indian Kings died.

df = Daru::DataFrame.new({
  name: ['Emperor Asoka', 'Akbar The Great', 'Rana Pratap', 'Shivaji Maharaj', 'Krishnadevaraya'],
  age:  [72,63,57,53,58] 
  }, order: [:name, :age])

df.sort!([:age])

Daru::View::Plot.new(df, type: :bar, x: :name, y: :age).chart.tap do |plot|
  plot.x_label "Name"
  plot.y_label "Age"
  plot.yrange [20,80]
end

a = ['A', 'C', 'G', 'T']
v = 1000.times.map { a.sample }

puts "v : ", v

df = Daru::DataFrame.new({
  a: v
  })
Daru::View::Plot.new(df, type: :bar, x: :a).chart.tap do |plot|
  plot.yrange [0,350]
  plot.y_label "Frequency"
  plot.x_label "Letter"
end

require 'distribution'
rng = Distribution::Normal.rng
# Daru.lazy_update = false

arr = []
1000.times {arr.push(rng.call)}

arr1 = arr.map{|val| val/0.8-2}
arr2 = arr.map{|val| val*1.1+0.3}
arr3 = arr.map{|val| val*1.3+0.3}

df = Daru::DataFrame.new({ a: arr, b: arr1, c: arr2, d: arr3 })
box_1 = Daru::View::Plot.new(df, type: :box)
box_1.show_in_iruby

df = Daru::DataFrame.new({
  temperature: [43,53,50,57,59,47],
  day:         [1,2,3,4,5,6]
})

line_1 = Daru::View::Plot.new(df,type: :line, x: :day, y: :temperature).chart
line_1.tap do |plot|
  plot.x_label "Day"
  plot.y_label "Temperature"
  plot.yrange [20,60]
  plot.xrange [1,6]
  plot.legend true
  plot.diagrams[0].title "Temperature in NYC"
end

v = 1000.times.map { rand }

df = Daru::DataFrame.new({
  a: v
  })

Daru::View::Plot.new(df, type: :histogram, x: :a).chart.tap do |plot|
  plot.yrange [0,150]
  plot.y_label "Frequency"
  plot.x_label "Bins"
end

df = Daru::DataFrame.new({
  nyc_temp:     [43,53,50,57,59,47],
  chicago_temp: [23,30,35,20,26,38],
  sf_temp:      [60,65,73,67,55,52],
  day:          [1 ,2 ,3 ,4 ,5 , 6]
  })

# As you can see, the options passed denote the x and y axes that are to be used by each diagram.
# You can add as many x any y axes as you want, just make sure the relevant vectors are present
# in your DataFrame!
#
# Heres an explanation of all the options passed:
#
# * type - The type of graph to be drawn. All the diagrams will be of the same type in this case.
# * x1/x2/x3 - The Vector from the DataFrame that is to be treated as the X axis for each of the 
# three diagrams. In this case all of them need the :day Vector.
# * y1/y2/y3 - The Vector from the DataFrame that is to be treated as the Y axis for each of the
# three diagrams. As you can see the 1st diagram will plot nyc_temp, the 2nd chicago_temp and the
# the 3rd sf_temp.
# 
# The values yielded in the block are also slightly different in this case.
# The first argument ('plot') is the same as in all the above examples (Nyaplot::Plot), but the 
# second argument ('diagrams') is now an Array of Nyaplot::Diagram objects. Each of the elements
# in the Array represents the diagrams that you want to plot according to the sorting sequence
# of the options specifying the axes.

graph = Daru::View::Plot.new(df, type: :scatter, x1: :day, y1: :nyc_temp, x2: :day, y2: :chicago_temp, x3: :day, y3: :sf_temp) 

graph.chart.tap do |plot|
  nyc     = plot.diagrams[0]
  chicago = plot.diagrams[1]
  sf      = plot.diagrams[2]
    
  nyc.title "Temprature in NYC"
  nyc.color "#00FF00"
  
  chicago.title "Temprature in Chicago"
  chicago.color "#FFFF00"
  
  sf.title "Temprature in SF"
  sf.color "#0000FF"
  
  plot.legend true
  plot.yrange [0,100]
  plot.x_label "Day"
  plot.y_label "Temperature"
end

df = Daru::DataFrame.new({
  burger: ["Hamburger","Cheeseburger","Quarter Pounder","Quarter Pounder with Cheese","Big Mac","Arch Sandwich Special","Arch Special with Bacon","Crispy Chicken","Fish Fillet","Grilled Chicken","Grilled Chicken Light"],
  fat: [9,13 ,21 ,30 ,31 ,31 ,34 ,25 ,28 ,20 ,5],
  calories: [260,320,420,530,560,550,590,500,560,440,300]
  },
  order: [:burger, :fat, :calories])

# Algorithm for computing the line of best fit

sum_x  = df[:fat].sum
sum2_x = (df[:fat]*df[:fat]).sum 
sum_xy = (df[:fat]*df[:calories]).sum
mean_x = df[:fat].mean
mean_y = df[:calories].mean

slope = (sum_xy - sum_x * mean_y) / (sum2_x - sum_x * mean_x)
yint  = mean_y - slope * mean_x

# Assign the computed Y co-ordinates of the line of best fit to a column 
# in the DataFrame called :y_coords
df[:y_coords] = df[:fat].map {|f| f*slope + yint }

# As you can see the options passed into plot are slightly different this time.
#
# Instead of passing Vector names into :x1, :x2... separately, this time we pass
# the relevant names of the X and Y axes co-ordinates as an Array into the :x and 
# :y options.This is a simpler and easier way to plot multiple diagrams.
# 
# As is demonstrated in the previous example, the first argument yields a Nyaplot::Plot
# object and the second an Array of Nyaplot::Diagram objects. The diagrams are ordered
# according to the types specified in the `:type` option.

graph = Daru::View::Plot.new(df, type: [:scatter, :line], x: [:fat, :fat], y: [:calories, :y_coords]) 
graph.chart.tap do |plot|
  plot.x_label "Fat"
  plot.y_label "Calories"
  plot.xrange [0,50]
  
  scatter = plot.diagrams[0]
  line    = plot.diagrams[1]
  
  line.color "#FF0000" #set color of the line to 'red'
  scatter.tooltip_contents [:burger] # set tool tip to :burger
end