CartesianPlot

Plot with Cartesian axes

Example usage

This class draws a sub-plot on Cartesian axes. This can be used to draw bar charts, scatter plots, box plots, contour plots etc.: anything that has an x- and a y-axis.

CartesianPlot instances can be sent directly to Plotly:

val xs = Vector(1, 2, 5)
val ys = Vector(2, 4, 9)
val plot = CartesianPlot().withScatter(xs, ys)
draw(plot, "my-scatter-plot")

They can also be embedded in Figure instances for more complex plot layouts:

val xs = Vector(1, 2, 5)
val ys1 = Vector(2, 4, 9)
val ys2 = Vector(2, 6, 12)

val figure = RowFigure(2) // 2 sub-plots next to each other
  .plot(0) { CartesianPlot().withScatter(xs, ys1) } // left subplot
  .plot(1) { CartesianPlot().withScatter(xs, ys2) } // right subplot

draw(figure, "multiple-plots")

Multiple lines

CartesianPlot instances support multiple series:

val xs = Vector(1, 2, 3)
val ys1 = xs.map { 2 * _ }
val ys2 = xs.map { -2 * _ }

val p = CartesianPlot()
  .withScatter(xs, ys1, ScatterOptions().name("series-1"))
  .withScatter(xs, ys2, ScatterOptions().name("series-2"))

draw(p, "multiple-series")

The immutable builder pattern

When you call the .withScatter method on a CartesianPlot object, it returns a new plot with the new data series added. CartesianPlot instances are immutable. Thus, the following will not work:

// Not what you want!
val p = CartesianPlot().withScatter(xs, ys1)
p.withScatter(xs, ys2) // No: this does not modify 'p' in place!

draw(p, "my-other-plot")

Do this instead:

val p = CartesianPlot().withScatter(xs, ys1)
val newPlot = p.withScatter(xs, ys2)

draw(newPlot, "my-other-plot")

Or, better yet, use chaining to avoid creating temporary variables:

val p = CartesianPlot()
  .withScatter(xs, ys1)
  .withScatter(xs, ys2)

draw(p, "another-plot")

All methods in this class work in the same way: they return a new instance of CartesianPlot. This pattern is called the immutable builder pattern: it is a variant of the common builder pattern adapted for immutable objects.

Linear Supertypes

Serializable, Serializable, Product, Equals, Plot, AnyRef, Any

Instance Constructors

new CartesianPlot(series: Vector[CartesianSeries], options: CartesianPlotOptions)

Type Members

type OptionType = CartesianPlotOptions

Definition Classes
CartesianPlot → Plot

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val options: CartesianPlotOptions

Definition Classes
CartesianPlot → Plot
val series: Vector[CartesianSeries]

Definition Classes
CartesianPlot → Plot
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def withBar[X, Y](xs: Iterable[X], ys: Iterable[Y])(implicit arg0: Writable[X], arg1: Writable[Y]): CartesianPlot

Add a bar series to this plot.
def withBox[X](xs: Iterable[X])(implicit arg0: Writable[X]): CartesianPlot

Add a box plot to this plot.
def withScatter[X, Y](xs: Iterable[X], ys: Iterable[Y], options: ScatterOptions): CartesianPlot

[use case] Add a scatter plot to this plot.
[use case]
Add a scatter plot to this plot.
xs
The 'xs' series. This can be an iterable of any type T, provided an instance of the typeclass 'Writable[T]' exists.
ys
The 'ys' series.
options
(optional) Options controlling the plot style.
returns
Copy of this plot with the scatter series added.
Full Signature
def withScatter[X, Y](xs: Iterable[X], ys: Iterable[Y], options: ScatterOptions = ScatterOptions())(implicit arg0: Writable[X], arg1: Writable[Y]): CartesianPlot
Example:
1. val xs = Vector(1.0, 2.0, 3.0) val ys1 = xs.map { _ * 2.0 } val ys2 = xs.map { _ * (-2.0) } val p = CartesianPlot() .withScatter(xs, ys1) .withScatter(xs, ys2, ScatterOptions().name("series-2"))
def xAxisOptions(newAxisOptions: AxisOptions): CartesianPlot

Set the x-axis options for this plot.
def yAxisOptions(newAxisOptions: AxisOptions): CartesianPlot

Set the y-axis options for this plot.

Related Docs: object CartesianPlot | package plotly

case class CartesianPlot(series: Vector[CartesianSeries], options: CartesianPlotOptions) extends Plot with Product with Serializable

Example usage

Multiple lines

The immutable builder pattern

Instance Constructors

new CartesianPlot(series: Vector[CartesianSeries], options: CartesianPlotOptions)

Type Members

type OptionType = CartesianPlotOptions

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def finalize(): Unit

final def getClass(): Class[_]

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val options: CartesianPlotOptions

val series: Vector[CartesianSeries]

final def synchronized[T0](arg0: ⇒ T0): T0

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def withBar[X, Y](xs: Iterable[X], ys: Iterable[Y])(implicit arg0: Writable[X], arg1: Writable[Y]): CartesianPlot

def withBox[X](xs: Iterable[X])(implicit arg0: Writable[X]): CartesianPlot

def withScatter[X, Y](xs: Iterable[X], ys: Iterable[Y], options: ScatterOptions): CartesianPlot

def withScatter[X, Y](xs: Iterable[X], ys: Iterable[Y], options: ScatterOptions = ScatterOptions())(implicit arg0: Writable[X], arg1: Writable[Y]): CartesianPlot

def xAxisOptions(newAxisOptions: AxisOptions): CartesianPlot

def yAxisOptions(newAxisOptions: AxisOptions): CartesianPlot

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from Plot

Inherited from AnyRef

Inherited from Any

Ungrouped