def hist_function(mean, sd, size=1000):
    '''
    Returns 1000 values picked at random from the normal
    distribution with the Mean value and SD given.
    '''
    return np.random.normal(loc=mean, scale=sd, size=1000)
options = {
    'title': 'Histogram',
    'xlabel': 'Mean value (mean)',
    'ylabel': 'Standard Deviation (sd)',
    'bins': 10
}
layouts = {
    'plot_height': '480px',
    'plot_width': '800px',
}
hist_chart = nbi.hist(
    hist_function,
    mean=(0, 10),
    sd=(0.2, 2.0, 0.2),
    options=options,
    layouts=layouts
)
hist_chart

nbinteract.hist(
    hist_function,
    *,  (1)
    options={},
    layouts={},
    **interact_params
)

hist_function (Array | (*args -> Array int | Array float)):
    Function that takes in parameters to interact with and returns an
    array of numbers. These numbers will be plotted in the resulting
    histogram.

interact_params (dict):
    Keyword arguments in the same format as `ipywidgets.interact`.
    One parameter is required for each argument of both `x_fn` and `y_fn`.
    If `x_fn` and `y_fn` have conflicting parameter names, prefix the
    corresponding kwargs with `x__` and
    `y__`.

import nbinteract as nbi
import numpy as np
def x_fn(n):
    return np.arange(n)
def y_fn(xs, offset):
    return xs + offset
options = {
    'ylim': (0, 20),
}
layouts = {
    'plot_height': '480px',
    'plot_width': '800px',
}
bar_chart = nbi.bar(
    x_fn,
    y_fn,
    n=(3, 10),
    offset=(1, 10),
    options=options,
    layouts=layouts
)
# print("Barchart Dataset: ", bar_chart)

bar_chart

nbinteract.bar(
    x_fn,
    y_fn,
    *,  (1)
    options={},
    layouts={},
    **interact_params
)

x_fn (Array | (*args -> Array str | Array int | Array float)):
    If array, uses array values for categories of bar chart.
    If function, must take parameters to interact with and return an
    array of strings or numbers. These will become the categories on
    the x-axis of the bar chart.
y_fn (Array | (Array, *args -> Array int | Array float)):
    If array, uses array values for heights of bars.
    If function, must take in the output of x_fn as its first parameter
    and optionally other parameters to interact with. Must return an
    array of numbers. These will become the heights of the bars on the
    y-axis.

import nbinteract as nbi
import numpy as np
from numpy import arange
x_points = np.arange(10)
y_points = np.arange(10) + np.random.rand(10)
options = {
    'title': 'Interactive Scatter Plot',
    'xlabel': 'x-values',
    'ylabel': 'y-values',
    'xlim': (0, 10),
    'ylim': (0, 10),
    'animation_duration': 1000
}
layouts = {
    'plot_height': '480px',
    'plot_width': '800px',
}
scatter_drag = nbi.scatter_drag(
    x_points,
    y_points,
    options=options,
    layouts=layouts
)
scatter_drag

nbinteract.scatter_drag(
    x_points: 'Array',
    y_points: 'Array',
    options={},
    layouts={}
)

x_points (Array Number): x-values of points to plot
y_points (Array Number): y-values of points to plot

def x_fn(n):
    return np.random.choice(100, n)
def y_fn(xs):
    return np.random.choice(100, len(xs))
options = {
    'title': 'Scatter Plot',
    'marker': 'circle',
    'animation_duration': 1000,
    'xlabel': 'x-values',
    'ylabel': 'y-values',
    'xlim': (0, 100),
    'ylim': (0, 100)
}
layouts = {
    'plot_height': '480px',
    'plot_width': '800px',
}
scatter_chart = nbi.scatter(
    x_fn,
    y_fn,
    n=(10,200),
    options=options,
    layouts=layouts
)
scatter_chart

nbinteract.scatter(
    x_fn,
    y_fn,
    *,  (1)
    options={},
    layouts={},
    **interact_params
)

x_fn (Array | (*args -> Array str | Array int | Array float)):
    If array, uses array values for x-coordinates.
    If function, must take parameters to interact with and return an
    array of strings or numbers. These will become the x-coordinates
    of the scatter plot.
y_fn (Array | (Array, *args -> Array int | Array float)):
    If array, uses array values for y-coordinates.
    If function, must take in the output of x_fn as its first parameter
    and optionally other parameters to interact with. Must return an
    array of numbers. These will become the y-coordinates of the
    scatter plot.

import nbinteract as nbi
import numpy as np
from numpy import arange
def x_fn(max):
    return np.arange(0, max + 1)
def y_fn(xs, sd):
    return xs + np.random.normal(0, scale=sd, size=len(xs))
options = {
    'title': 'Line chart',
    'xlabel': 'x-values (max)',
    'ylabel': 'y-values (sd)',
    'xlim': (0, 50),
    'ylim': (-20, 70),
    'animation_duration': 500
}
layouts = {
    'plot_height': '480px',
    'plot_width': '800px',
}
line_chart = nbi.line(
    x_fn,
    y_fn,
    max=(10, 50),
    sd=(0, 10),
    options=options,
    layouts=layouts
)
line_chart

nbinteract.line(
    x_fn,
    y_fn,
    *,  (1)
    options={},
    layouts={},
    **interact_params
)

x_fn (Array | (*args -> Array str | Array int | Array float)):
    If array, uses array values for x-coordinates.
    If function, must take parameters to interact with and return an
    array of strings or numbers. These will become the x-coordinates
    of the line plot.
y_fn (Array | (Array, *args -> Array int | Array float)):
    If array, uses array values for y-coordinates.
    If function, must take in the output of x_fn as its first parameter
    and optionally other parameters to interact with. Must return an
    array of numbers. These will become the y-coordinates of the line
    plot.

interact_params (dict):
    Keyword arguments in the same format as `ipywidgets.interact`.
    One parameter is required for each argument of both `x_fn` and `y_fn`.
    If `x_fn` and `y_fn` have conflicting parameter names, prefix the
    corresponding kwargs with `x__` and `y__`

import nbinteract as nbi
multiple_choice = nbi.multiple_choice(
    question="Select all prime numbers.",
    choices=['12', '3', '31'],
    answers=[1, 2]
)
multiple_choice

nbinteract.multiple_choice(
    question,
    choices,
    answers
)

import nbinteract as nbi
short_answer = nbi.short_answer(
    'What is 1+1?',
    answers='2',
    explanation='1+1 is 2'
)
short_answer

nbinteract.short_answer(
    question,
    answers,
    explanation
)