Module: Plotrb::Simple

Defined in:
lib/plotrb/simple.rb

Constant Summary collapse

SCATTER_DATA_NAME = 
'scatter'
SCATTER_X_SCALE_NAME = 
'scatter_x'
SCATTER_Y_SCALE_NAME = 
'scatter_y'

Class Method Summary collapse

Class Method Details

.scatter(x, y, kwargs = {}) ⇒ Plotrb::Visualization

Generate a simple 2d scatter plot.

method signature for ruby 2.0 kwargs: def scatter(x, y, symbol: ‘circle’, color: ‘blue’, markersize: 20,

width: 640, height: 480, domain: nil, range: nil)



97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
 
# File 'lib/plotrb/simple.rb', line 97

def self.scatter(x, y, kwargs={})
  kwargs = {symbol: 'circle', color: 'blue', markersize: 20, width: 640,
            height: 480, domain: nil, range: nil}.merge(kwargs)
  symbol = kwargs[:symbol]
  color = kwargs[:color]
  markersize = kwargs[:markersize]
  width = kwargs[:width]
  height = kwargs[:height]
  domain = kwargs[:domain]
  range = kwargs[:range]
  
  datapoints = []
  n_sets = 1
  x_n_sets = 1
  x_size = x.size

  if x.respond_to?(:shape) and x.shape.length > 1 then  # x is 2D NMatrix
    x_n_sets = x.shape[0]
    x_size = x.shape[1]
  elsif x.instance_of? Array and x[0].instance_of? Array then # x is nested Array
    x_n_sets = x.size
    x_size = x[0].size
  end

  if y.respond_to?(:shape) and y.shape.length > 1 then # y is 2D NMatrix
    n_sets = y.shape[0]
  elsif y.instance_of? Array and y[0].instance_of? Array then # y is nested array
    n_sets = y.size
  end

  x_size.times do |i|
    dp = {}
    n_sets.times do |j|

      xj = j.modulo(x_n_sets)
      if x.respond_to?(:shape) and x.shape.length > 1 then
        dp["x#{xj}".to_sym] = x[xj, i]
      elsif x.instance_of? Array and x[0].instance_of? Array then
        dp["x#{xj}".to_sym] = x[xj][i]
      else
        dp["x#{xj}".to_sym] = x[i]
      end

      indices = [i]
      if y.respond_to?(:shape) and y.shape.length > 1 then
        indices = [j,i]
      end
      if y.instance_of? Array and y[0].instance_of? Array then
        dp["y#{j}".to_sym] = y[j][*indices]
      else
        dp["y#{j}".to_sym] = y[*indices]
      end
    end

    datapoints << dp
  end

  Plotrb::Kernel.data.delete_if { |d| d.name == scatter_data_name }
  dataset= Plotrb::Data.new.name(scatter_data_name)
  dataset.values(datapoints)

  domain_in = "#{scatter_data_name}.x0"
  if domain then
    domain_in = domain
  end
  range_in = "#{scatter_data_name}.y0"
  if range then
    range_in = range
  end

  Plotrb::Kernel.scales.delete_if { |d| d.name == scatter_x_scale_name or d.name == scatter_y_scale_name }

  xs = linear_scale.name(scatter_x_scale_name).from(domain_in).to_width
  ys = linear_scale.name(scatter_y_scale_name).from(range_in).to_height

  marks = []
  n_sets.times do |j|
    marks << symbol_mark.from(dataset) do
      c_j = color.instance_of?(Array) ? color[j] : color
      s_j = symbol.instance_of?(Array) ? symbol[j] : symbol
      x_j = j.modulo(x_n_sets)
      enter do
        x_start { scale(xs).from("x#{x_j}") }
        y_start { scale(ys).from("y#{j}") }
        size markersize
        shape s_j
        fill c_j
      end
    end
  end

  visualization.width(width).height(height) do
    data dataset
    scales xs, ys
    marks marks
    axes x_axis.scale(xs), y_axis.scale(ys)
  end
end

.scatter_data_name ⇒ Object

Data name used by scatter plot



43
44
45
 
# File 'lib/plotrb/simple.rb', line 43

def self.scatter_data_name
  SCATTER_DATA_NAME
end

.scatter_x_scale_name ⇒ Object

Scale name used by scatter plot for x axis



50
51
52
 
# File 'lib/plotrb/simple.rb', line 50

def self.scatter_x_scale_name
  SCATTER_X_SCALE_NAME
end

.scatter_y_scale_name ⇒ Object

Scale name used by scatter plot for y axis



57
58
59
 
# File 'lib/plotrb/simple.rb', line 57

def self.scatter_y_scale_name
  SCATTER_Y_SCALE_NAME
end