charty 0.2.0 → 0.2.6

data/lib/charty/plotters/count_plotter.rb

@@ -0,0 +1,7 @@
+module Charty
+  module Plotters
+    class CountPlotter < BarPlotter
+      self.require_numeric = false
+    end
+  end
+end

data/lib/charty/plotters/estimation_support.rb

@@ -0,0 +1,84 @@
+module Charty
+  module Plotters
+    module EstimationSupport
+      attr_reader :estimator
+
+      def estimator=(estimator)
+        @estimator = check_estimator(estimator)
+      end
+
+      module_function def check_estimator(value)
+        case value
+        when :count, "count"
+          :count
+        when :mean, "mean"
+          :mean
+        when :median
+          raise NotImplementedError,
+                "median estimator has not been supported yet"
+        when Proc
+          raise NotImplementedError,
+                "a callable estimator has not been supported yet"
+        else
+          raise ArgumentError,
+                "invalid value for estimator (%p for :mean)" % value
+        end
+      end
+
+      attr_reader :ci
+
+      def ci=(ci)
+        @ci = check_ci(ci)
+      end
+
+      private def check_ci(value)
+        case value
+        when nil
+          nil
+        when :sd, "sd"
+          :sd
+        when 0..100
+          value
+        when Numeric
+          raise ArgumentError,
+                "ci must be in 0..100, but %p is given" % value
+        else
+          raise ArgumentError,
+                "invalid value for ci (%p for nil, :sd, or a number in 0..100)" % value
+        end
+      end
+
+      attr_reader :n_boot
+
+      def n_boot=(n_boot)
+        @n_boot = check_n_boot(n_boot)
+      end
+
+      private def check_n_boot(value)
+        case value
+        when Integer
+          if value <= 0
+            raise ArgumentError,
+                  "n_boot must be larger than zero, but %p is given" % value
+          end
+          value
+        else
+          raise ArgumentError,
+                "invalid value for n_boot (%p for an integer > 0)" % value
+        end
+      end
+
+      attr_reader :units
+
+      def units=(units)
+        @units = check_dimension(units, :units)
+        unless units.nil?
+          raise NotImplementedError,
+                "Specifying units variable is not supported yet"
+        end
+      end
+
+      include RandomSupport
+    end
+  end
+end

data/lib/charty/plotters/line_plotter.rb

@@ -0,0 +1,300 @@
+module Charty
+  module Plotters
+    class EstimateAggregator
+      def initialize(estimator, error_bar, n_boot, random)
+        @estimator = estimator
+        @method, @level = error_bar
+        @n_boot = n_boot
+        @random = random
+      end
+
+      # Perform aggregation
+      #
+      # @param data [Hash<Any, Charty::Table>]
+      # @param var_name [Symbol, String]  A column name to be aggregated
+      def aggregate(data, var_name)
+        values = data[var_name]
+        estimation = case @estimator
+                     when :count
+                       values.length
+                     when :mean
+                       values.mean
+                     end
+
+        n = values.length
+        case
+        # No error bars
+        when @method.nil?
+          err_min = err_max = Float::NAN
+        when n <= 1
+          err_min = err_max = Float::NAN
+
+        # User-defined method
+        when @method.respond_to?(:call)
+          err_min, err_max = @method.call(values)
+
+        # Parametric
+        when @method == :sd
+          err_radius = values.stdev * @level
+          err_min = estimation - err_radius
+          err_max = estimation + err_radius
+        when @method == :se
+          err_radius = values.stdev / Math.sqrt(n)
+          err_min = estimation - err_radius
+          err_max = estimation + err_radius
+
+        # Nonparametric
+        when @method == :pi
+          err_min, err_max = percentile_interval(values, @level)
+        when @method == :ci
+          # TODO: Support units
+          err_min, err_max =
+            Statistics.bootstrap_ci(values, @level, units: nil, func: @estimator,
+                                    n_boot: @n_boot, random: @random)
+        end
+
+        {
+          var_name => estimation,
+          "#{var_name}_min" => err_min,
+          "#{var_name}_max" => err_max
+        }
+      end
+
+      def percentile_interval(values, width)
+        q = [50 - width / 2, 50 + width / 2]
+        Statistics.percentile(values, q)
+      end
+    end
+
+    class LinePlotter < RelationalPlotter
+      def initialize(data: nil, variables: {}, **options, &block)
+        x, y, color, style, size = variables.values_at(:x, :y, :color, :style, :size)
+        super(x, y, color, style, size, data: data, **options, &block)
+
+        @comp_data = nil
+      end
+
+      attr_reader :estimator
+
+      def estimator=(estimator)
+        @estimator = check_estimator(estimator)
+      end
+
+      private def check_estimator(value)
+        case value
+        when nil, false
+          nil
+        when :count, "count"
+          :count
+        when :mean, "mean"
+          :mean
+        when :median
+          raise NotImplementedError,
+                "median estimator has not been supported yet"
+        when Proc
+          raise NotImplementedError,
+                "a callable estimator has not been supported yet"
+        else
+          raise ArgumentError,
+                "invalid value for estimator (%p for :mean)" % value
+        end
+      end
+
+      attr_reader :n_boot
+
+      def n_boot=(n_boot)
+        @n_boot = check_n_boot(n_boot)
+      end
+
+      private def check_n_boot(value)
+        case value
+        when Integer
+          if value <= 0
+            raise ArgumentError,
+                  "n_boot must be larger than zero, but %p is given" % value
+          end
+          value
+        else
+          raise ArgumentError,
+                "invalid value for n_boot (%p for an integer > 0)" % value
+        end
+      end
+
+      include RandomSupport
+
+      attr_reader :sort, :err_style, :err_kws, :error_bar, :x_scale, :y_scale
+
+      def sort=(val)
+        @sort = check_boolean(val, :sort)
+      end
+
+      def err_style=(val)
+        @err_style = check_err_style(val)
+      end
+
+      private def check_err_style(val)
+        case val
+        when :bars, "bars", :band, "band"
+          val.to_sym
+        else
+          raise ArgumentError,
+                "Invalid value for err_style (%p for :band or :bars)" % val
+        end
+      end
+
+      # parameters to draw error bars/bands
+      def err_params=(val)
+        unless val.nil?
+          raise NotImplementedError,
+                "Specifying `err_params` is not supported"
+        end
+      end
+
+      # The method and level to calculate error bars/bands
+      def error_bar=(val)
+        @error_bar = check_error_bar(val)
+      end
+
+      DEFAULT_ERROR_BAR_LEVELS = {
+        ci: 95,
+        pi: 95,
+        se: 1,
+        sd: 1
+      }.freeze
+
+      VALID_ERROR_BAR_METHODS = DEFAULT_ERROR_BAR_LEVELS.keys
+      VALID_ERROR_BAR_METHODS.concat(VALID_ERROR_BAR_METHODS.map(&:to_s))
+      VALID_ERROR_BAR_METHODS.freeze
+
+      private def check_error_bar(val)
+        case val
+        when nil
+          return [nil, nil]
+        when ->(x) { x.respond_to?(:call) }
+          return [val, nil]
+        when *VALID_ERROR_BAR_METHODS
+          method = val.to_sym
+          level = nil
+        when Array
+          if val.length != 2
+            raise ArgumentError,
+                  "The `error_bar` array has the wrong number of items " +
+                  "(%d for 2)" % val.length
+          end
+          method, level = *val
+        else
+          raise ArgumentError,
+                "Unable to recognize the value for `error_bar`: %p" % val
+        end
+
+        case method
+        when *VALID_ERROR_BAR_METHODS
+          method = method.to_sym
+        else
+          error_message = "The value for method in `error_bar` array must be in %p, but %p was passed" % [
+            DEFAULT_ERROR_BAR_LEVELS.keys,
+            method
+          ]
+          raise ArgumentError, error_message
+        end
+
+        case level
+        when Numeric
+          # nothing to do
+        when nil
+          level = DEFAULT_ERROR_BAR_LEVELS[method]
+        else
+          raise ArgumentError,
+                "The value of level in `error_bar` array must be a number "
+        end
+
+        [method, level]
+      end
+
+      def x_scale=(val)
+        @x_scale = check_axis_scale(val, :x)
+      end
+
+      def y_scale=(val)
+        @y_scale = check_axis_scale(val, :y)
+      end
+
+      private def check_axis_scale(val, axis)
+        case val
+        when :linear, "linear", :log10, "log10"
+          val.to_sym
+        else
+          raise ArgumentError,
+                "The value of `#{axis}_scale` is worng: %p" % val,
+                caller
+        end
+      end
+
+      private def render_plot(backend, **)
+        draw_lines(backend)
+        annotate_axes(backend)
+      end
+
+      private def draw_lines(backend)
+        map_color(palette: palette, order: color_order, norm: color_norm)
+        map_size(sizes: sizes, order: size_order, norm: size_norm)
+        map_style(markers: markers, dashes: dashes, order: style_order)
+
+        aggregator = EstimateAggregator.new(estimator, error_bar, n_boot, random)
+
+        agg_var = :y
+        grouper = :x
+        grouping_vars = [:color, :size, :style]
+
+        each_subset(grouping_vars, processed: true) do |sub_vars, sub_data|
+          if self.sort
+            sort_cols = [:units, :x, :y] & self.variables.keys
+            sub_data = sub_data.sort_values(sort_cols)
+          end
+
+          unless estimator.nil?
+            if self.variables.include?(:units)
+              raise "`estimator` is must be nil when specifying `units`"
+            end
+
+            grouped = sub_data.group_by(grouper, sort: self.sort)
+            sub_data = grouped.apply(agg_var, &aggregator.method(:aggregate)).reset_index
+          end
+
+          # TODO: perform inverse conversion of axis scaling before plot
+
+          unit_grouping = if self.variables.include?(:units)
+                            sub_data.group_by(:units).each_group
+                          else
+                            { nil => sub_data }
+                          end
+          unit_grouping.each do |_unit_value, unit_data|
+            ci_params = unless self.estimator.nil? || self.error_bar.nil?
+                          {
+                            style: self.err_style,
+                            y_min: sub_data[:y_min],
+                            y_max: sub_data[:y_max]
+                          }
+                        end
+            backend.line(unit_data[:x], unit_data[:y], self.variables,
+                         color: sub_vars[:color], color_mapper: @color_mapper,
+                         size: sub_vars[:size], size_mapper: @size_mapper,
+                         style: sub_vars[:style], style_mapper: @style_mapper,
+                         ci_params: ci_params)
+          end
+        end
+
+        if legend
+          backend.add_line_plot_legend(@variables, @color_mapper, @size_mapper, @style_mapper, legend)
+        end
+      end
+
+      private def annotate_axes(backend)
+        xlabel = self.variables[:x]
+        ylabel = self.variables[:y]
+        backend.set_xlabel(xlabel) unless xlabel.nil?
+        backend.set_ylabel(ylabel) unless ylabel.nil?
+      end
+    end
+  end
+end

data/lib/charty/plotters/random_support.rb

@@ -0,0 +1,25 @@
+module Charty
+  module Plotters
+    module RandomSupport
+      attr_reader :random
+
+      def random=(random)
+        @random = check_random(random)
+      end
+
+      module_function def check_random(random)
+        case random
+        when nil
+          Random.new
+        when Integer
+          Random.new(random)
+        when Random
+          random
+        else
+          raise ArgumentError,
+                "invalid value for random (%p for a generator or a seed value)" % value
+        end
+      end
+    end
+  end
+end

data/lib/charty/plotters/relational_plotter.rb

@@ -0,0 +1,635 @@
+module Charty
+  module Plotters
+    class BaseMapper
+      def initialize(plotter, *params)
+        @plotter = plotter
+        initialize_mapping(*params)
+      end
+
+      attr_reader :plotter
+
+      def [](key, *args)
+        case key
+        when Array, Charty::Vector
+          key.map {|k| lookup_single_value(k, *args) }
+        else
+          lookup_single_value(key, *args)
+        end
+      end
+
+      private def categorical_lut_from_hash(levels, pairs, name)
+        missing_keys = levels - pairs.keys
+        unless missing_keys.empty?
+          raise ArgumentError,
+                "The `#{name}` hash is missing keys: %p" % missing_keys
+        end
+        pairs.dup
+      end
+
+      private def categorical_lut_from_array(levels, values, name)
+        if levels.length != values.length
+          raise ArgumentError,
+            "The `#{name}` array has the wrong number of values " +
+            "(%d for %d)." % [values.length, levels.length]
+        end
+        levels.zip(values).to_h
+      end
+    end
+
+    # TODO: This should be replaced with red-colors's Normalize feature
+    class SimpleNormalizer
+      def initialize(vmin=nil, vmax=nil)
+        @vmin = vmin
+        @vmax = vmax
+      end
+
+      attr_accessor :vmin, :vmax
+
+      def call(value, clip=nil)
+        scalar_p = false
+        vector_p = false
+        case value
+        when Charty::Vector
+          vector_p = true
+          value = value.to_a
+        when Array
+          # do nothing
+        else
+          scalar_p = true
+          value = [value]
+        end
+
+        @vmin = value.min if vmin.nil?
+        @vmax = value.max if vmax.nil?
+
+        result = value.map {|x| (x - vmin) / (vmax - vmin).to_f }
+
+        case
+        when scalar_p
+          result[0]
+        when vector_p
+          Charty::Vector.new(result, index: value.index)
+        else
+          result
+        end
+      end
+    end
+
+    class ColorMapper < BaseMapper
+      private def initialize_mapping(palette, order, norm)
+        @palette = palette
+        @order = order
+
+        if plotter.variables.key?(:color)
+          data = plotter.plot_data[:color]
+        end
+
+        if data && data.notnull.any?
+          @map_type = infer_map_type(palette, norm, @plotter.input_format, @plotter.var_types[:color])
+
+          case @map_type
+          when :numeric
+            @levels, @lookup_table, @norm, @cmap = numeric_mapping(data, palette, norm)
+          when :categorical
+            @cmap = nil
+            @norm = nil
+            @levels, @lookup_table = categorical_mapping(data, palette, order)
+          else
+            raise NotImplementedError,
+                  "datetime color mapping is not supported"
+          end
+        end
+      end
+
+      private def numeric_mapping(data, palette, norm)
+        case palette
+        when Hash
+          levels = palette.keys.sort
+          colors = palette.values_at(*levels)
+          cmap = Colors::ListedColormap.new(colors)
+          lookup_table = palette.dup
+        else
+          levels = data.drop_na.unique_values
+          levels.sort!
+
+          palette ||= "ch:"
+          cmap = case palette
+                 when Colors::Colormap
+                   palette
+                 else
+                   Palette.new(palette, 256).to_colormap
+                 end
+
+          case norm
+          when nil
+            norm = SimpleNormalizer.new
+          when Array
+            norm = SimpleNormalizer.new(*norm)
+          #when Colors::Normalizer
+          # TODO: Must support red-color's Normalize feature
+          else
+            raise ArgumentError,
+                  "`color_norm` must be nil, Array, or Normalizer object"
+          end
+
+          # initialize norm
+          norm.(data.drop_na.to_a)
+
+          lookup_table = levels.map { |level|
+            [
+              level,
+              cmap[norm.(level)]
+            ]
+          }.to_h
+        end
+
+        return levels, lookup_table, norm, cmap
+      end
+
+      private def categorical_mapping(data, palette, order)
+        levels = data.categorical_order(order)
+        n_colors = levels.length
+
+        case palette
+        when Hash
+          lookup_table = categorical_lut_from_hash(levels, palette, :palette)
+          return levels, lookup_table
+
+        when nil
+          current_palette = Palette.default
+          if n_colors <= current_palette.n_colors
+            colors = Palette.new(current_palette.colors, n_colors).colors
+          else
+            colors = Palette.husl_colors(n_colors)
+          end
+
+        when Array
+          colors = palette
+
+        else
+          colors = Palette.new(palette, n_colors).colors
+        end
+
+        lookup_table = categorical_lut_from_array(levels, colors, :palette)
+        return levels, lookup_table
+      end
+
+      private def infer_map_type(palette, norm, input_format, var_type)
+        case
+        when false # palette is qualitative_palette
+          :categorical
+        when ! norm.nil?
+          :numeric
+        when palette.is_a?(Array),
+             palette.is_a?(Hash)
+          :categorical
+        when input_format == :wide
+          :categorical
+        else
+          var_type
+        end
+      end
+
+      attr_reader :palette, :norm, :levels, :lookup_table, :map_type
+
+      def inverse_lookup_table
+        lookup_table.invert
+      end
+
+      def lookup_single_value(key)
+        if @lookup_table.key?(key)
+          @lookup_table[key]
+        elsif @norm
+          # Use the colormap to interpolate between existing datapoints
+          begin
+            normed = @norm.(key)
+            @cmap[normed]
+          rescue ArgumentError, TypeError => err
+            if Util.nan?(key)
+              return "#000000"
+            else
+              raise err
+            end
+          end
+        end
+      end
+    end
+
+    class SizeMapper < BaseMapper
+      private def initialize_mapping(sizes, order, norm)
+        @sizes = sizes
+        @order = order
+        @norm = norm
+
+        return unless plotter.variables.key?(:size)
+
+        data = plotter.plot_data[:size]
+        return unless data.notnull.any?
+
+        @map_type = infer_map_type(sizes, norm, @plotter.var_types[:size])
+        case @map_type
+        when :numeric
+          @levels, @lookup_table, @norm = numeric_mapping(data, sizes, norm)
+        when :categorical
+          @levels, @lookup_table = categorical_mapping(data, sizes, order)
+        else
+          raise NotImplementedError,
+                "datetime color mapping is not supported"
+        end
+      end
+
+      private def infer_map_type(sizes, norm, var_type)
+        case
+        when ! norm.nil?
+          :numeric
+        when sizes.is_a?(Hash),
+             sizes.is_a?(Array)
+          :categorical
+        else
+          var_type
+        end
+      end
+
+      private def numeric_mapping(data, sizes, norm)
+        case sizes
+        when Hash
+          # The presence of a norm object overrides a dictionary of sizes
+          # in specifying a numeric mapping, so we need to process the
+          # dictionary here
+          levels = sizes.keys.sort
+          size_values = sizes.values
+          size_range = [size_values.min, size_values.max]
+        else
+          levels = Charty::Vector.new(data.unique_values).drop_na.to_a
+          levels.sort!
+
+          case sizes
+          when Range
+            size_range = [sizes.begin, sizes.end]
+          when nil
+            size_range = [0r, 1r]
+          else
+            raise ArgumentError,
+                  "Unable to recognize the value for `sizes`: %p" % sizes
+          end
+        end
+
+        # Now we have the minimum and the maximum values of sizes
+        case norm
+        when nil
+          norm = SimpleNormalizer.new
+          sizes_scaled = norm.(levels)
+        # when Colors::Normalize
+        # TODO: Must support red-color's Normalize feature
+        else
+          raise ArgumentError,
+                "Unable to recognize the value for `norm`: %p" % norm
+        end
+
+        case sizes
+        when Hash
+          # do nothing
+        else
+          lo, hi = size_range
+          sizes = sizes_scaled.map {|x| lo + x * (hi - lo) }
+          lookup_table = levels.zip(sizes).to_h
+        end
+
+        return levels, lookup_table, norm
+      end
+
+      private def categorical_mapping(data, sizes, order)
+        levels = data.categorical_order(order)
+
+        case sizes
+        when Hash
+          lookup_table = categorical_lut_from_hash(levels, sizes, :sizes)
+          return levels, lookup_table
+
+        when Array
+          # nothing to do
+
+        when Range, nil
+          # Reverse values to use the largest size for the first category
+          size_range = sizes || (0r .. 1r)
+          sizes = Linspace.new(size_range, levels.length).reverse_each.to_a
+        else
+          raise ArgumentError,
+            "Unable to recognize the value for `sizes`: %p" % sizes
+        end
+
+        lookup_table = categorical_lut_from_array(levels, sizes, :sizes)
+        return levels, lookup_table
+      end
+
+      attr_reader :palette, :order, :norm, :levels, :lookup_table, :map_type
+
+      def lookup_single_value(key)
+        if @lookup_table.key?(key)
+          @lookup_table[key]
+        else
+          normed = @norm.(key) || Float::NAN
+          size_values = @lookup_table.values
+          min, max = size_values.min, size_values.max
+          min + normed * (max - min)
+        end
+      end
+    end
+
+    class StyleMapper < BaseMapper
+      private def initialize_mapping(markers, dashes, order)
+        @markers = markers
+        @dashes = dashes
+        @order = order
+
+        return unless plotter.variables.key?(:style)
+
+        data = plotter.plot_data[:style]
+        return unless data.notnull.any?
+
+        @levels = data.categorical_order(order)
+
+        markers = map_attributes(markers, @levels, unique_markers(@levels.length), :markers)
+        dashes = map_attributes(dashes, @levels, unique_dashes(@levels.length), :dashes)
+
+        @lookup_table = @levels.map {|key|
+          record = {
+            marker: markers[key],
+            dashes: dashes[key]
+          }
+          record.compact!
+          [key, record]
+        }.to_h
+      end
+
+      MARKER_NAMES = [
+        :circle,      :x,           :square,        :cross,   :diamond, :star_diamond,
+        :triangle_up, :star_square, :triangle_down, :hexagon, :star,    :pentagon,
+      ].freeze
+
+      private def unique_markers(n)
+        if n > MARKER_NAMES.length
+          raise ArgumentError,
+                "Too many markers are required (%p for %p)" % [n, MARKER_NAMES.length]
+        end
+        MARKER_NAMES[0, n]
+      end
+
+      private def unique_dashes(n)
+        DashPatternGenerator.take(n)
+      end
+
+      private def map_attributes(vals, levels, defaults, attr)
+        case vals
+        when true
+          return levels.zip(defaults).to_h
+        when Hash
+          missing_keys = lavels - vals.keys
+          unless missing_keys.empty?
+            raise ArgumentError,
+                  "The `%s` levels are missing values: %p" % [attr, missing_keys]
+          end
+          return vals
+        when Array, Enumerable
+          if levels.length != vals.length
+            raise ArgumentError,
+                  "%he `%s` argument has the wrong number of values" % attr
+          end
+          return levels.zip(vals).to_h
+        when nil, false
+          return {}
+        else
+          raise ArgumentError,
+                "Unable to recognize the value for `%s`: %p" % [attr, vals]
+        end
+      end
+
+      attr_reader :palette, :order, :norm, :lookup_table, :levels
+
+      def inverse_lookup_table(attr)
+        lookup_table.map { |k, v| [v[attr], k] }.to_h
+      end
+
+      def lookup_single_value(key, attr=nil)
+        case attr
+        when nil
+          @lookup_table[key]
+        else
+          @lookup_table[key][attr]
+        end
+      end
+    end
+
+    class RelationalPlotter < AbstractPlotter
+      def flat_structure
+        {
+          x: :index,
+          y: :values
+        }
+      end
+
+      def initialize(x, y, color, style, size, data: nil, **options, &block)
+        super(x, y, color, data: data, **options, &block)
+
+        self.style = style
+        self.size = size
+
+        setup_variables
+      end
+
+      attr_reader :style, :size, :units
+
+      attr_reader :color_norm
+
+      attr_reader :sizes, :size_order, :size_norm
+
+      attr_reader :markers, :dashes, :style_order
+
+      attr_reader :legend
+
+      def units=(units)
+        @units = check_dimension(units, :units)
+      end
+
+      def style=(val)
+        @style = check_dimension(val, :style)
+      end
+
+      def size=(val)
+        @size = check_dimension(val, :size)
+      end
+
+      def color_norm=(val)
+        unless val.nil?
+          raise NotImplementedError,
+                "Specifying color_norm is not supported yet"
+        end
+      end
+
+      def sizes=(val)
+        # NOTE: the value check will be perfomed in SizeMapper
+        @sizes = val
+      end
+
+      def size_order=(val)
+        unless val.nil?
+          raise NotImplementedError,
+                "Specifying size_order is not supported yet"
+        end
+      end
+
+      def size_norm=(val)
+        unless val.nil?
+          raise NotImplementedError,
+                "Specifying size_order is not supported yet"
+        end
+      end
+
+      def markers=(val)
+        @markers = check_markers(val)
+      end
+
+      private def check_markers(val)
+        # TODO
+        val
+      end
+
+      def dashes=(val)
+        @dashes = check_dashes(val)
+      end
+
+      private def check_dashes(val)
+        # TODO
+        val
+      end
+
+      def style_order=(val)
+        unless val.nil?
+          raise NotImplementedError,
+                "Specifying style_order is not supported yet"
+        end
+      end
+
+      def legend=(val)
+        case val
+        when :auto, :brief, :full, false
+          @legend = val
+        when "auto", "brief", "full"
+          @legend = val.to_sym
+        else
+          raise ArgumentError,
+                "invalid value of legend (%p for :auto, :brief, :full, or false)" % val
+        end
+      end
+
+      attr_reader :input_format, :plot_data, :variables, :var_types
+
+      private def setup_variables
+        if x.nil? && y.nil?
+          @input_format = :wide
+          setup_variables_with_wide_form_dataset
+        else
+          @input_format = :long
+          setup_variables_with_long_form_dataset
+        end
+
+        @var_types = @plot_data.columns.map { |k|
+          [k, variable_type(@plot_data[k], :categorical)]
+        }.to_h
+      end
+
+      private def setup_variables_with_wide_form_dataset
+        unless color.nil? && style.nil? && size.nil?
+          vars = []
+          vars << "color" unless color.nil?
+          vars << "style" unless style.nil?
+          vars << "size"  unless size.nil?
+          raise ArgumentError,
+                "Unable to assign the following variables in wide-form data: " +
+                vars.join(", ")
+        end
+
+        if data.nil? || data.empty?
+          @plot_data = Charty::Table.new({})
+          @variables = {}
+          return
+        end
+
+        flat = data.is_a?(Charty::Vector)
+        if flat
+          @plot_data = {}
+          @variables = {}
+
+          [:x, :y].each do |var|
+            case self.flat_structure[var]
+            when :index
+              @plot_data[var] = data.index.to_a
+              @variables[var] = data.index.name
+            when :values
+              @plot_data[var] = data.to_a
+              @variables[var] = data.name
+            end
+          end
+
+          @plot_data = Charty::Table.new(@plot_data)
+        else
+          raise NotImplementedError,
+                "wide-form input is not supported"
+        end
+      end
+
+      private def setup_variables_with_long_form_dataset
+        self.data = {} if data.nil?
+
+        plot_data = {}
+        variables = {}
+
+        {
+          x: self.x,
+          y: self.y,
+          color: self.color,
+          style: self.style,
+          size: self.size,
+          units: self.units
+        }.each do |key, val|
+          next if val.nil?
+
+          if data.column?(val)
+            plot_data[key] = data[val]
+            variables[key] = val
+          else
+            case val
+            when Charty::Vector
+              plot_data[key] = val
+              variables[key] = val.name
+            else
+              raise ArgumentError,
+                    "Could not interpret value %p for parameter %p" % [val, key]
+            end
+          end
+        end
+
+        @plot_data = Charty::Table.new(plot_data)
+        @variables = variables.select do |var, name|
+          @plot_data[var].notnull.any?
+        end
+      end
+
+      private def annotate_axes(backend)
+        # TODO
+      end
+
+      private def map_color(palette: nil, order: nil, norm: nil)
+        @color_mapper = ColorMapper.new(self, palette, order, norm)
+      end
+
+      private def map_size(sizes: nil, order: nil, norm: nil)
+        @size_mapper = SizeMapper.new(self, sizes, order, norm)
+      end
+
+      private def map_style(markers: nil, dashes: nil, order: nil)
+        @style_mapper = StyleMapper.new(self, markers, dashes, order)
+      end
+    end
+  end
+end