Dowell Statistical Distributions From Big Data API

Unlock the Power of Big Data with Dowell’s Precise Statistical Distributions

Dowell Statistical Distribution API

Dowell Statistical Distributions From Big Data API

Our API makes it super easy for you to get exactly the data you need from your database. Whether you’re looking for specific information or want to explore patterns, our tool lets you pick the perfect filtration method for your needs. Choose from options like Normal, Poisson, Binomial, and Bernoulli distributions to filter your data just the way you want it.

Key Features

distribution

Normal Distribution

Easily apply the Normal distribution method to analyze your data, ensuring precision and accuracy in your insights. Define parameters such as error tolerance and range effortlessly.

distribution

Poisson Distribution

Gain insights into event occurrences over time with the Poisson distribution option. Split your data into intervals like weeks or days, allowing for granular analysis and trend identification.

distribution

Binomial Distribution

Utilize the Binomial distribution feature to assess outcomes of binary events accurately. Define variables such as the number of trials and success criteria with ease, facilitating efficient analysis of probabilistic outcomes.

distribution

Bernoulli Distribution

Assess the likelihood of success or failure for single binary events using the Bernoulli distribution. Define error margins and selection criteria effortlessly, enabling precise analysis and decision-making based on probability theory.

API Usage Guidelines

Request method: POST

Request URL:  http://100032.pythonanywhere.com/api/targeted_population/

"database_details": {
    'database_name': 'mongodb', # database type
    'collection': 'some_collection', # collection name
    'database': 'some_data_base', # database name
    'fields':['a_field_name'] # column name or field name
}

The database name and collection name of the targeted data. The fields are those fields or column name on which the distribution logic will be applied.

"time_input" : {
    'column_name': 'Date', # column name for the date
    'split':'week', # split for poisson distribution
    'period': 'life_time', # the period from which data will be taken
    'start_point': '2021/01/08', # start point for custom period
    'end_point': '2021/01/25', # end point for custom period
}

For time input

Period can be 'custom' or 'last_1_day' or 'last_30_days' or 'last_90_days' or 'last_180_days' or 'last_1_year' or 'life_time' and if 'custome' is given then need to specify start_point and end_point

'split' value is required for poisson distribution. Split value can be 'week''hour''day''month'.

Stage input list

"stage_input_list": [
{
        'd': 1,
        'm_or_A_selction': 'population_average',
        'm_or_A_value': 300,
        'error': 10,
        'r': 100,
        'start_point': 0,
        'end_point': 700,
        'a': 2,
    },
]

statge_input_list is a list of stages

For Norml distribution a stage can have

{
       'd': 1,
       'm_or_A_selction': 'population_average',
       'm_or_A_value': 300,
       'error': 10,
       'r': 100,
       'start_point': 0,
       'end_point': 700,
       'a': 2,
}
  • datatype can be 0 to 7.
  • 'm_or_A_selction' can be 'maximum_point' or 'population_average'
  • 'm_or_A_value' is value of the maximum_point' or 'population_average'
  • error is the error allowed in percentage
  • r is range
  • start_point is the starting value of that stage
  • end_point is the maximum value.
  • a is the number of item that can be taken in a range
"distribution_input": {
    'normal': 1,
    'poisson':0,
    'binomial':0,
    'bernoulli':1
}

Give 1 if expecting the output for the respective distribution Give 0 if not expecting output for that distribution Binomial distribution

If we are expecting binomial distribution result we need to provide the binomial distribution specific inputs.

"binomial" : {
    'number_of_variable':13,
    'split_choice': 'simple',
    'split_decision': "Eliminate",
    'user_choice_value': 43,
    'function': ">",
    'marginal_error': "0",
    'error': 20,
}

'split_choice' can be 'simple' or 'calculated' 'split_decision' can be 'Eliminate' or 'Check_Accuracy' 'function' can be '>' , '=' , '<'

For Bernoulli distribution

Bernoulli specific distribution is required while expecting result from Bernoulli distribution.

'bernoulli': {
    'error_size': 0.167,
    'test_number': 7,
    'selection_start_point': 500,
    'items_to_be_selected': 600,
}

Curl example

curl --location 'http://100032.pythonanywhere.com/api/targeted_population/' \
--data '{
    "database_details": {
        "database_name": "mongodb",
        "collection": "test",
        "database": "Bangalore",
        "fields": [
            "LENGTH"
        ]
    },
    "distribution_input": {
        "normal": 1,
        "poisson": 1,
        "binomial": 0,
        "bernoulli": 0
    },
    "number_of_variable": 1,
    "stages": [
    ],
    "time_input": {
        "column_name": "Date",
        "split": "week",
        "period": "life_time",
        "start_point": "2021/01/08",
        "end_point": "2021/01/25"
    },
    "binomial": {},
    "bernoulli": {}
}'

Dowell Statistical Distributions From Big Data API Demonstrative Scenarios

In the following scenarios, Dowell will furnish comprehensive instructions on obtaining the Service key and guide you through the steps to use the API. You’ll find examples in various formats such as Python, PHP, React, Flutter, and WordPress in the tabs below. Feel free to explore the examples in each tab for practical insights.

Dowell Statistical Distributions From Big Data API Use Cases

Dive into the world of data with Dowell’s Statistical Distributions From Big Data API! Uncover hidden insights, predict future trends, and make informed decisions effortlessly. Discover how to analyze vast datasets, build predictive models, and gain valuable insights for smarter decision-making. Watch now for a data-driven journey!

FAQs about Dowell Statistical Distributions From Big Data API

You can specify the database name, collection name, and field/column names in the database_details section of the request.

You can specify the time column name, split (for Poisson distribution), and period (like last 30 days) in the time_input section.

Stages are customizable sections where you define parameters for distribution calculations. You can specify parameters like range, error, and distribution type within each stage.

Sure! You can specify parameters like the number of variables, split choice, split decision, and error percentage in the binomial section.

For the Bernoulli distribution, you can set parameters such as error size, test number, selection start point, and items to be selected in the bernoulli section.

If you encounter any issues, have questions, or need assistance with Dowell Statistical Distributions From Big Data API, you can contact the support team for prompt assistance. Contact us at Dowell@dowellresearch.uk 

Yes, you can specify a custom time period by setting the period to ‘custom’ in the time_input section and providing the start and end points.

The API’s performance may depend on various factors like server capacity and network speed, but there’s no explicit limit mentioned in the documentation.

If you have suggestions for improving the documentation or feedback on the API functionality, you can reach out to the API provider through their support channels or documentation feedback options.

Dowell UX Living Lab offers a wide range of APIs to enhance user experience and streamline various processes. To explore the full list of APIs available, including Dowell Email, Dowell Newsletter, Samanta Content Evaluator, and many more.

For more details and to explore the complete list of APIs provided by Dowell UX Living Lab, please visit our documentation page.

How To Get The API Key

How to activate Dowell statistical distribution from big data

Python Example

This Python code makes a POST request to the specified API endpoint with various parameters. These parameters define details about the database, time periods, stages, and distribution types. The API responds with statistical data based on the provided parameters.

				
					import json
import requests


url = 'http://100032.pythonanywhere.com/api/targeted_population/'


database_details = {
    'database_name': 'mongodb',
    'collection': 'test',
    'database': 'Bangalore',
    'fields':["LENGTH"]
}


# number of variables for sampling rule
number_of_variables = 1

# for first stage it's mandatory to have d=5
# period can be 'custom' or 'last_1_day' or 'last_30_days' or 'last_90_days' or 'last_180_days' or 'last_1_year' or 'life_time'
# if custom is given then need to specify start_point and end_point
# for others datatpe 'm_or_A_selction' can be 'maximum_point' or 'population_average'
# the the value of that selection in 'm_or_A_value'
# error is the error allowed in percentage


time_input = {
    'column_name': 'Date',
    'split': 'week',
    'period': 'life_time',
    'start_point': '2021/01/08',
    'end_point': '2021/01/25',
}

stage_input_list = [
    {
        'data_type': 1,
        'm_or_A_selction': 'maximum_point',
        'm_or_A_value': 500,
        'error': 40,
        'r': 100,
        'start_point': 0,
        'end_point': 700,
        'a': 2,
    }
]

# distribution input
distribution_input={
    'normal': 1,
    'poisson':1,
    'binomial':1,
    'bernoulli':0
    
}

bernoulli = {
    'error_size': 0.167,
    'test_number': 7,
    'selection_start_point': 500,
    'items_to_be_selected': 600,
}


binomial = {
    'number_of_variable':13,
    'split_choice': 'simple',
    'split_decision': "Eliminate",
    'user_choice_value': 43,
    'function': "&gt;",
    'marginal_error': "0",
    'error': 20,
}




request_data = {
    'database_details': database_details,
    'distribution_input': distribution_input,
    'number_of_variable': number_of_variables,
    'stages': stage_input_list,
    'time_input': time_input,
    'binomial': binomial,
    'bernoulli': bernoulli,
}



headers = {'content-type': 'application/json'}

response = requests.post(url, json=request_data,headers=headers)

print(response.text)
				
			

PHP Example

The PHP code performs a POST request to the API with parameters defining database details, time periods, stages, and distribution types. It echoes the API response.

				
					$url = 'http://100032.pythonanywhere.com/api/targeted_population/';

$requestData = array(
    'database_details' =&gt; array(
        'database_name' =&gt; 'mongodb',
        'collection' =&gt; 'test',
        'database' =&gt; 'Bangalore',
        'fields' =&gt; ["LENGTH"],
    ),
    'number_of_variable' =&gt; 1,
    'time_input' =&gt; array(
        'column_name' =&gt; 'Date',
        'split' =&gt; 'week',
        'period' =&gt; 'life_time',
        'start_point' =&gt; '2021/01/08',
        'end_point' =&gt; '2021/01/25',
    ),
    'stages' =&gt; array(
        array(
            'data_type' =&gt; 1,
            'm_or_A_selction' =&gt; 'maximum_point',
            'm_or_A_value' =&gt; 500,
            'error' =&gt; 40,
            'r' =&gt; 100,
            'start_point' =&gt; 0,
            'end_point' =&gt; 700,
            'a' =&gt; 2,
        ),
    ),
    'distribution_input' =&gt; array(
        'normal' =&gt; 1,
        'poisson' =&gt; 1,
        'binomial' =&gt; 1,
        'bernoulli' =&gt; 0,
    ),
    'bernoulli' =&gt; array(
        'error_size' =&gt; 0.167,
        'test_number' =&gt; 7,
        'selection_start_point' =&gt; 500,
        'items_to_be_selected' =&gt; 600,
    ),
    'binomial' =&gt; array(
        'number_of_variable' =&gt; 13,
        'split_choice' =&gt; 'simple',
        'split_decision' =&gt; 'Eliminate',
        'user_choice_value' =&gt; 43,
        'function' =&gt; '&gt;',
        'marginal_error' =&gt; '0',
        'error' =&gt; 20,
    ),
);

$headers = array('content-type' =&gt; 'application/json');

$ch = curl_init($url);

curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($requestData));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);

if ($response === false) {
    echo 'cURL error: ' . curl_error($ch);
}

curl_close($ch);

echo $response;

				
			

React Example

In the React implementation, the code sends a POST request to the API, including parameters for database details, time periods, stages, and distribution types. The response is displayed in the component.

				
					import React, { useEffect, useState } from 'react';

function App() {
  const [response, setResponse] = useState(null);

  useEffect(() =&gt; {
    const apiUrl = 'http://100032.pythonanywhere.com/api/targeted_population/';

    const requestData = {
      database_details: {
        database_name: 'mongodb',
        collection: 'test',
        database: 'Bangalore',
        fields: ["LENGTH"],
      },
      number_of_variable: 1,
      time_input: {
        column_name: 'Date',
        split: 'week',
        period: 'life_time',
        start_point: '2021/01/08',
        end_point: '2021/01/25',
      },
      stages: [
        {
          data_type: 1,
          m_or_A_selction: 'maximum_point',
          m_or_A_value: 500,
          error: 40,
          r: 100,
          start_point: 0,
          end_point: 700,
          a: 2,
        },
      ],
      distribution_input: {
        normal: 1,
        poisson: 1,
        binomial: 1,
        bernoulli: 0,
      },
      bernoulli: {
        error_size: 0.167,
        test_number: 7,
        selection_start_point: 500,
        items_to_be_selected: 600,
      },
      binomial: {
        number_of_variable: 13,
        split_choice: 'simple',
        split_decision: 'Eliminate',
        user_choice_value: 43,
        function: '&gt;',
        marginal_error: '0',
        error: 20,
      },
    };

    const requestOptions = {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(requestData),
    };

    fetch(apiUrl, requestOptions)
      .then((response) =&gt; response.text())
      .then((data) =&gt; setResponse(data))
      .catch((error) =&gt; console.error('Request failed:', error));
  }, []);

  return (
    <div>
      {response &amp;&amp; <pre>{response}</pre>}
    </div>
  );
}

export default App;

				
			

Flutter Example

The Flutter application actively makes a POST request to the API, providing parameters that specify database details, time periods, stages, and distribution types. The app then displays the response.

				
					import 'package:flutter/material.dart';
import 'package:http/http.dart as http;
import 'dart:convert';

void main() =&gt; runApp(MyApp());

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: MyHomePage(),
    );
  }
}

class MyHomePage extends StatefulWidget {
  @override
  _MyHomePageState createState() =&gt; _MyHomePageState();
}

class _MyHomePageState extends State {
  var response;
  final apiUrl = 'http://100032.pythonanywhere.com/api/targeted_population/';

  @override
  void initState() {
    super.initState();
    fetchData();
  }

  Future fetchData() async {
    final Map requestData = {
      'database_details': {
        'database_name': 'mongodb',
        'collection': 'test',
        'database': 'Bangalore',
        'fields': ["LENGTH"],
      },
      'number_of_variable': 1,
      'time_input': {
        'column_name': 'Date',
        'split': 'week',
        'period': 'life_time',
        'start_point': '2021/01/08',
        'end_point': '2021/01/25',
      },
      'stages': [
        {
          'data_type': 1,
          'm_or_A_selction': 'maximum_point',
          'm_or_A_value': 500,
          'error': 40,
          'r': 100,
          'start_point': 0,
          'end_point': 700,
          'a': 2,
        },
      ],
      'distribution_input': {
        'normal': 1,
        'poisson': 1,
        'binomial': 1,
        'bernoulli': 0,
      },
      'bernoulli': {
        'error_size': 0.167,
        'test_number': 7,
        'selection_start_point': 500,
        'items_to_be_selected': 600,
      },
      'binomial': {
        'number_of_variable': 13,
        'split_choice': 'simple',
        'split_decision': 'Eliminate',
        'user_choice_value': 43,
        'function': '&gt;',
        'marginal_error': '0',
        'error': 20,
      },
    };

    final headers = {'content-type': 'application/json'};

    final http.Response apiResponse = await http.post(
      Uri.parse(apiUrl),
      body: jsonEncode(requestData),
      headers: headers,
    );

    if (apiResponse.statusCode == 200) {
      setState(() {
        response = apiResponse.body;
      });
    } else {
      print('Request failed with status code: ${apiResponse.statusCode}');
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Flutter App')),
      body: Center(
        child: response != null
            ? Text(response)
            : CircularProgressIndicator(),
      ),
    );
  }
}

				
			

WordPress Example

Step 1: Set up the API name, unique ID and the base url(below). It’s a prerequisite to have WP-GET API plugin installed in your wordpress website

DoWell-Statistical-distributions-from-bigdata. Set up the API name, unique ID and the base url.

Step 2: Set up the api endpoint and the request body. The request body should have the necessary body post fields

DoWell-Statistical-distributions-from-bigdata api endpoint and query params
DoWell-Statistical-distributions-from-bigdata body fields
DoWell-Statistical-distributions-from-bigdata body fields

Step 3: Test endpoint to get Json response from the API.

DoWell-Statistical-distributions-from-bigdata api response