jdrawinglib

# Plotting functions

There are several ways of plotting mathematical functions with `jdrawinglib`, but the easiest way is to use `Calculable` and `GFormula`.

All the code examples assume you are using the [[Examples#usage-template|usage template]].

## Import the classes

```java

import com.dkt.graphics.exceptions.DomainException;

import com.dkt.graphics.extras.GFormula;

import com.dkt.graphics.extras.formula.Calculable;

```

## Create a new `Calculable` object and implement `f(x)`

In our case we are implementing a simple `sin(x)`, since all the real numbers are a part of the domain of `sin(x)` we won't bother with the `DomainException`.

```java

Calculable calculable = new Calculable() {

    @Override

    public double f(double x) throws DomainException {

        return Math.sin(x);

    }

};

```

Since the image of `sin(x)` is the interval `[-1, 1]` and the domain of a period is `[0, 2π]` the height will be just two pixels and the width ~6 pixels, so in order to make it look nice, we'll need something like:

```java

calculable.setScaleX(40);

calculable.setScaleY(60);

```

## Create a `GFormula` and calculate it

`Calculable` objects are just a container for `f(x)` and it's scales, but the real calculation is done by `GFormula`. This class provides some methods to calculate paths, areas and points.

```java

GFormula formula = new GFormula(calculable);

// Paints should be set before calling the calculate methods

// I use -π to π so the function is centered

formula.calculatePath(-Math.PI, Math.PI, 0.01);

canvas.add(formula);

```

## Beautify it

This isn't actually necessary, but it does give a nice effect. First we'll create a `GAxis` object and add it to the canvas, since the axis should really be behind the graph, this could be achieved by adding the axis first, or simply adding the axis to the background of the canvas with

`canvas.addFixed(GraphicE)`.

```java

GAxis axis = new GAxis(-300, 300, -300, 300);

axis.drawLinesH(true);

axis.drawLinesV(true);

canvas.addFixed(axis);

```

And the final result should be something like this (the final code is [here `->` attachment:Plotting.java):

![Screenshot](sin.png)

## Beautify it some more

In the following code we'll add some color to the graph, and paint an area changing the stroke used to show the area. in order to do this we must set the `Paint` before calculating the path. So the code will end up:

```java

GFormula formula = new GFormula(calculable);

formula.setPaint(Color.ORANGE); // <--

formula.calculatePath(-Math.PI, Math.PI, 0.01);

```

Now we need to calculate the area, lets say we want to color the area in the interval `(1, 2)` to that end we need a new `GFormula` object, since the idea is making it look nice, lets put a transparent color on the area, and a dashed  `Stroke`. The code will be something like:

```java

import com.dkt.graphics.utils.Utils;

import java.awt.BasicStroke;

import java.awt.Color;

import java.awt.Stroke;

```

```java

// This variables aren't really necessary, but the code

// needs to be short for the wiki.

final int cap  = BasicStroke.CAP_ROUND;

final int join = BasicStroke.JOIN_ROUND;

final float[] dash = new float[] {5, 5};

Stroke stroke = new BasicStroke(1, cap, join, 0, dash, 0);

// This creates a new color with 32 as the alpha value

Color background = Utils.getColorWithAlpha(Color.GREEN, 32);

GFormula area = new GFormula(calculable);

area.setAreaPaint(background);

area.setPaint(Color.GREEN);

area.setStroke(stroke);

// Calculate the area in the interval

area.calculateArea(1, 2, 0.01);

```

So the final code (attachment:Plotting2.java) will result in the following output:

![Screenshot](sin2.png)