Add comments

.brackets.json

@@ -1,3 +0,0 @@
-{
-    "sbruchmann.staticpreview.basepath": "/home/carto/Projects/crankshaft/"
-}

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,7 +0,0 @@
-
-- [ ] All declared geometries are `geometry(Geometry, 4326)` for general geoms, or `geometry(Point, 4326)`
-- [ ] Existing functions in crankshaft python library called from the extension are kept at least from version N to version N+1 (to avoid breakage during upgrades).
-- [ ] Docs for public-facing functions are written
-- [ ] New functions follow the naming conventions: `CDB_NameOfFunction`. Where internal functions begin with an underscore `_`.
-- [ ] If appropriate, new functions accepts an arbitrary query as an input (see [Crankshaft Issue #6](https://github.com/CartoDB/crankshaft/issues/6) for more information)
- 

.gitignore

@@ -1,4 +0,0 @@
-envs/
-*.pyc
-.DS_Store
-.idea/

.travis.yml

@@ -1,57 +0,0 @@
-language: c
-
-env:
-  global:
-    - PAGER=cat
-
-before_install:
-  - ./check-up-to-date-with-master.sh
-  - sudo apt-get -y install python-pip
-
-  - sudo apt-get -y install python-software-properties
-  - sudo add-apt-repository -y ppa:cartodb/sci
-  - sudo add-apt-repository -y ppa:cartodb/postgresql-9.5
-  - sudo add-apt-repository -y ppa:cartodb/gis
-  - sudo add-apt-repository -y ppa:cartodb/gis-testing
-  - sudo apt-get update
-
-  - sudo apt-get -y install python-joblib=0.8.3-1-cdb1
-  - sudo apt-get -y install python-numpy=1:1.6.1-6ubuntu1
-
-  # Install pysal
-  - sudo pip install -I pysal==1.11.2
-
-  - sudo apt-get -y install python-scipy=0.14.0-2-cdb6
-  - sudo apt-get -y --no-install-recommends install python-sklearn-lib=0.14.1-3-cdb2
-  - sudo apt-get -y --no-install-recommends install python-sklearn=0.14.1-3-cdb2
-  - sudo apt-get -y --no-install-recommends install python-scikits-learn=0.14.1-3-cdb2
-
-  # Force instalation of libgeos-3.5.0 (presumably needed because of existing version of postgis)
-  - sudo apt-get -y install libgeos-3.5.0=3.5.0-1cdb2
-
-  # Install postgres db and build deps
-  - sudo /etc/init.d/postgresql stop # stop travis default instance
-  - sudo apt-get -y remove --purge postgresql-9.1
-  - sudo apt-get -y remove --purge postgresql-9.2
-  - sudo apt-get -y remove --purge postgresql-9.3
-  - sudo apt-get -y remove --purge postgresql-9.4
-  - sudo apt-get -y remove --purge postgis
-  - sudo apt-get -y autoremove
-
-  - sudo apt-get -y install postgresql-9.5=9.5.2-2ubuntu1
-  - sudo apt-get -y install postgresql-server-dev-9.5=9.5.2-2ubuntu1
-  - sudo apt-get -y install postgresql-plpython-9.5=9.5.2-2ubuntu1
-  - sudo apt-get -y install postgresql-9.5-postgis-2.2=2.2.2.0-cdb2
-  - sudo apt-get -y install postgresql-9.5-postgis-scripts=2.2.2.0-cdb2
-
-  # configure it to accept local connections from postgres
-  - echo -e "# TYPE  DATABASE        USER            ADDRESS                 METHOD \nlocal   all             postgres                                trust\nlocal   all             all                                     trust\nhost    all             all             127.0.0.1/32            trust" \
-    | sudo tee /etc/postgresql/9.5/main/pg_hba.conf
-  - sudo /etc/init.d/postgresql restart 9.5
-
-install:
-  - sudo make install
-
-script:
-  - make test || { cat src/pg/test/regression.diffs; false; }
-  - ./check-compatibility.sh

CONTRIBUTING.md

@@ -1,57 +1,84 @@
-# Development process
+# Contributing guide
 
-For any modification of crankshaft, such as adding new features,
-refactoring or bugfixing, a topic branch must be created out of the `develop`.
+## How to add new functions
 
-Modifications are done inside `src/pg/sql` and `src/py/crankshaft`.
+Try to put as little logic in the SQL extension as possible and
+just use it as a wrapper to the Python module functionality.
 
-Take into account:
+Once a function is defined it should never change its signature in subsequent
+versions. To change a function's signature a new function with a different
+name must be created.
 
-*  Tests must be added for any new functionality
-   (inside `src/pg/test`, `src/py/crankshaft/test`) as well as to
-   detect any bugs that are being fixed.
-*  Add or modify the corresponding documentation files in the `doc` folder.
-*  Naming conventions for function names:
-   - use `CamelCase`
-   - prefix "public" functions with `CDB_`. E.g: `CDB_SpatialMarkovTrend`
-   - prefix "private" functions with an underscore. E.g: `_CDB_MyObscureInternalImplementationDetail`
+### Version numbers
 
-Once the code is ready to be tested, update the local development installation
-with `sudo make install`.
-This will update the 'dev' version of the extension in `src/pg/` and
-make it available to PostgreSQL.
+The version of both the SQL extension and the Python package shall
+follow the[Semantic Versioning 2.0](http://semver.org/) guidelines:
 
-Run the tests with `make test`.
+* When backwards incompatibility is introduced the major number is incremented
+* When functionally is added (in a backwards-compatible manner) the minor number
+  is incremented
+* When only fixes are introduced (backwards-compatible) the patch number is
+  incremented
 
-Update extension in a working database with:
+### Python Package
 
-```sql
-ALTER EXTENSION crankshaft UPDATE TO 'current';
-ALTER EXTENSION crankshaft UPDATE TO 'dev';
+...
+
+### SQL Extension
+
+* Generate a **new subfolder version** for `sql` and `test` folders to define
+  the new functions and tests
+  - Use symlinks to avoid file duplication between versions that don't update them
+  - Add new files or modify copies of the old files to add new functions or
+    modify existing functions (remember to rename a function if the signature
+    changes)
+  - Add or modify the corresponding documentation files in the `doc` folder.
+    Since we expect to have highly technical functions here, an extense
+    background explanation would be of great help to users of this extension.
+  - Create tests for the new functions/behaviour
+
+* Generate the **upgrade and downgrade files** for the extension
+
+* Update the control file and the Makefile to generate the complete SQL
+  file for the new created version. After running `make` a new
+  file `crankshaft--X.Y.Z.sql` will be created for the current version.
+  Additional files for migrating to/from the previous version A.B.Z should be
+  created:
+  - `crankshaft--X.Y.Z--A.B.C.sql`
+  - `crankshaft--A.B.C--X.Y.Z.sql`
+  All these new files must be added to git and pushed.
+
+* Update the public docs! ;-)
+
+## Conventions
+
+# SQL
+
+Use snake case (i.e. `snake_case` and not `CamelCase`) for all
+functions. Prefix functions intended for public use with `cdb_`
+and private functions (to be used only internally inside
+the extension)  with `_cdb_`.
+
+# Python
+
+...
+
+## Testing
+
+Running just the Python tests:
+
+```
+(cd python && make test)
 ```
 
-If the extension has not previously been installed in a database,
-it can be installed directly with:
-```sql
-CREATE EXTENSION IF NOT EXISTS plpythonu;
-CREATE EXTENSION IF NOT EXISTS postgis;
-CREATE EXTENSION crankshaft WITH VERSION 'dev';
+Installing the Extension and running just the PostgreSQL tests:
+
+```
+(cd pg && sudo make install && PGUSER=postgres make installcheck)
 ```
 
-Once the feature or bugfix is completed and all the tests are passing
-a pull request shall be created, reviewed by a peer
-and then merged back into the `develop` branch once all the CI tests pass.
+Installing and testing everything:
 
-
-## Relevant development targets in the Makefile
-
-```shell
-# Show a short description of the available targets
-make help
-
-# Generate the extension scripts and install the python package.
-sudo make install
-
-#  Run the tests against the installed extension.
-make test
+```
+sudo make install && PGUSER=postgres make testinstalled
 ```

DEPLOYING.md

@@ -0,0 +1,43 @@
+# Workflow
+
+... (branching/merging flow)
+
+# Deployment
+
+...
+
+Deployment to db servers: the next command will install both the Python
+package and the extension.
+
+```
+sudo make install
+```
+
+Installing only the Python package:
+
+```
+sudo pip install python/crankshaft --upgrade
+```
+
+Caveat: note that `pip install ./crankshaft` will install
+from local files, but `pip install crankshaft` will not.
+
+CI: Install and run the tests on the installed extension and package:
+
+```
+(sudo make install && PGUSER=postgres make testinstalled)
+```
+
+Installing the extension in user databases:
+Once installed in a server, the extension can be added
+to a database with the next SQL command:
+
+```
+CREATE EXTENSION crankshaft;
+```
+
+To upgrade the extension to an specific version X.Y.Z:
+
+```
+ALTER EXTENSION crankshaft UPGRADE TO 'X.Y.Z';
+```

Makefile

@@ -1,64 +1,13 @@
-include ./Makefile.global
-
-EXT_DIR = src/pg
-PYP_DIR = src/py
+EXT_DIR = pg
+PYP_DIR = python
 
 .PHONY: install
 .PHONY: run_tests
-.PHONY: release
-.PHONY: deploy
 
-# Generate and install developmet versions of the extension
-# and python package.
-# The extension is named 'dev' with a 'current' alias for easily upgrading.
-# Requires sudo.
-install: ## Generate and install development version of the extension; requires sudo.
+install:
 	$(MAKE) -C $(PYP_DIR) install
 	$(MAKE) -C $(EXT_DIR) install
 
-# Run the tests for the installed development extension and
-# python package
-test:   ## Run the tests for the development version of the extension
-	$(MAKE) -C $(PYP_DIR) test
-	$(MAKE) -C $(EXT_DIR) test
-
-# Generate a new release into release
-release: ## Generate a new release of the extension. Only for telease manager
-	$(MAKE) -C $(EXT_DIR) release
-	$(MAKE) -C $(PYP_DIR) release
-
-# Install the current release.
-# Requires sudo.
-# Use the RELEASE_VERSION environment variable to deploy a specific version:
-#     sudo make deploy RELEASE_VERSION=1.0.0
-deploy: ## Deploy a released extension. Only for release manager. Requires sudo.
-	$(MAKE) -C $(EXT_DIR) deploy
-	$(MAKE) -C $(PYP_DIR) deploy
-
-# Cleanup development extension script files
-clean-dev: ## clean up development extension script files
-	rm -f src/pg/$(EXTENSION)--*.sql
-
-# Cleanup all releases
-clean-releases: ## clean up all releases
-	rm -rf release/python/*
-	rm -f release/$(EXTENSION)--*.sql
-	rm -f release/$(EXTENSION).control
-
-# Cleanup current/specific version
-clean-release: ## clean up current release
-	rm -rf release/python/$(RELEASE_VERSION)
-	rm -f release/$(RELEASE_VERSION)--*.sql
-
-clean-all: clean-dev clean-release
-
-help:
-	@IFS=$$'\n' ; \
-	help_lines=(`fgrep -h "##" $(MAKEFILE_LIST) | fgrep -v fgrep | sed -e 's/\\$$//'`); \
-	for help_line in $${help_lines[@]}; do \
-		IFS=$$'#' ; \
-		help_split=($$help_line) ; \
-		help_command=`echo $${help_split[0]} | sed -e 's/^ *//' -e 's/ *$$//'` ; \
-		help_info=`echo $${help_split[2]} | sed -e 's/^ *//' -e 's/ *$$//'` ; \
-		printf "%-30s %s\n" $$help_command $$help_info ; \
-	done
+testinstalled:
+	$(MAKE) -C $(PYP_DIR) testinstalled
+	$(MAKE) -C $(EXT_DIR) installcheck

Makefile.global

@@ -1,6 +0,0 @@
-SELF_DIR         := $(dir $(lastword $(MAKEFILE_LIST)))
-EXTENSION         = crankshaft
-PACKAGE           = crankshaft
-EXTVERSION        = $(shell grep default_version $(SELF_DIR)/src/pg/$(EXTENSION).control | sed -e "s/default_version[[:space:]]*=[[:space:]]*'\([^']*\)'/\1/")
-RELEASE_VERSION  ?= $(EXTVERSION)
-SED               = sed

NEWS.md

@@ -1,56 +0,0 @@
-0.4.2 (2016-09-22)
-------------------
-* Bugfix for cdb_areasofinterestglobal: import correct modules
-
-0.4.1 (2016-09-21)
-------------------
-* Let the user set the resolution in CDB_Contour function
-* Add Nearest Neighbors method to CDB_SpatialInterpolation
-* Improve error reporting for moran and markov functions
-
-0.4.0 (2016-08-30)
-------------------
-* Add CDB_Contour
-* Add CDB_PIA
-* Add CDB_Densify
-* Add CDB_TINmap
-
-0.3.1 (2016-08-18)
-------------------
-* Fix Voronoi projection issue
-* Fix Voronoi spurious segments issue
-* Add tests for interpolation
-
-0.3.0 (2016-08-17)
-------------------
-* Adds Voronoi function
-* Fixes barycenter method in interpolation
-
-0.2.0 (2016-08-11)
-------------------
-* Adds Gravity Model
-
-0.1.0 (2016-06-29)
-------------------
-* Adds Spatial Markov function
-* Adds Spacial interpolation function
-* Adds `CDB_pyAgg (columns Numeric[])` helper function
-* Adds Segmentation Functions
-
-0.0.4 (2016-06-20)
-------------------
-* Remove cartodb extension dependency from tests
-* Declare all correct dependencies with correct versions in setup.py
-
-0.0.3 (2016-06-16)
-------------------
-* Adds new functions: kmeans, weighted centroids.
-* Replaces moran functions with new areas of interest naming.
-
-0.0.2 (2016-03-16)
-------------------
-* New versioning approach using per-version Python virtual environments
-
-0.0.1 (2016-02-22)
-------------------
-* Preliminar release

README.md

@@ -1,67 +1,14 @@
-# Crankshaft [![Build Status](https://travis-ci.org/CartoDB/crankshaft.svg?branch=develop)](https://travis-ci.org/CartoDB/crankshaft)
+# crankshaft
 
-CARTO Spatial Analysis extension for PostgreSQL.
+CartoDB Spatial Analysis extension for PostgreSQL.
 
 ## Code organization
 
-* `doc/` documentation
-* `src/` source code
- - `pg/` contains the PostgreSQL extension source code
- - `py/` Python module source code
-* `release` reseleased versions
+* *pg* contains the PostgreSQL extension source code
+* *python* Python module
+
+FIXME: should it be `./extension` and `./lib/python' ?
 
 ## Requirements
 
-* PostgreSQL
-* plpythonu and postgis extensions
-* python-scipy system package (see [src/py/README.md](https://github.com/CartoDB/crankshaft/blob/develop/src/py/README.md))
-
-# Development Process
-
-We distinguish two roles:
-
-* *developers* will implement new functionality and bugfixes into
-  the codebase.
-* A *release manager* will handle the release process.
-
-We use the branch `develop` as the main integration branch for development. The `master` is reserved to handle releases.
-
-The process is as follows:
-
-1. Create a new **topic branch** from `develop` for any new feature
-or bugfix and commit their changes to it:
-
-  ```shell
-  git fetch && git checkout -b my-cool-feature origin/develop
-  ```
-1. Code, commit, push, repeat.
-1. Write some **tests** for your feature or bugfix.
-1. Update the [NEWS.md](https://github.com/CartoDB/crankshaft/blob/develop/NEWS.md) doc.
-1. Create a pull request and mention relevant people for a **peer review**.
-1. Address the comments and improvements you get from the peer review.
-1. Mention `@CartoDB/dataservices` in the PR to get it merged into `develop`.
-
-In order for a pull request to be accepted, the following criteria should be met:
-* The peer review should pass and no major issue should be left unaddressed.
-* CI tests must pass (travis will take care of that).
-
-
-## Development Guidelines
-
-For a detailed description of the development process please see
-the [CONTRIBUTING.md](https://github.com/CartoDB/crankshaft/blob/develop/CONTRIBUTING.md) guide.
-
-
-## Testing
-
-The tests (both for SQL and Python) are executed by running, from the top directory:
-
-```shell
-sudo make install
-make test
-```
-
-## Release
-
-The release process is described in the
-[RELEASE.md](https://github.com/CartoDB/crankshaft/blob/develop/RELEASE.md) guide and is the responsibility of the designated *release manager*.
+* pip

RELEASE.md

@@ -1,54 +0,0 @@
-# Release & Deployment Process
-
-The release process of a new version of the extension
-shall be performed by the designated *Release Manager*.
-
-## Release steps
-1. Make sure `develop` branch passes all the tests.
-1. Merge `develop` into `master`
-1. Update the version number in `src/pg/crankshaft.control`.
-1. Generate the next release files with this command:
-
-  ```shell
-  make release
-  ```
-1. Generate an upgrade path from the previous to the next release by copying the generated release file. E.g:
-
-  ```shell
-  cp release/crankshaft--X.Y.Z.sql release/crankshaft--A.B.C--X.Y.Z.sql
-  ```
-  NOTE: you can rely on this thanks to the compatibility checks. 
-  
-  TODO: automate this step [#94](https://github.com/CartoDB/crankshaft/issues/94)
-2. Update the [NEWS.md](https://github.com/CartoDB/crankshaft/blob/master/NEWS.md) file
-1. Commit and push the generated files.
-1. Tag the release:
-
-  ```
-  git tag -a X.Y.Z -m "Release X.Y.Z"
-  git push origin X.Y.Z
-  ```
-1. Deploy and test in staging
-1. Deploy and test in production
-1. Merge back into develop
-
-
-## Some remarks
-* Version numbers shall follow [Semantic Versioning 2.0](http://semver.org/).
-* CI tests will take care of **forward compatibility** of the extension at postgres level.
-* **Major version changes** (breaking forward compatibility) are a major event and are out of the scope of this doc. They **shall be avoided as much as we can**.
-* We will go forward, never backwards. **Generating upgrade paths automatically is easy** and we'll rely on the CI checks for that.
-
-## Deploy commands
-
-The new release can be deployed for staging/smoke tests with this command:
-
-  ```shell
-  sudo make deploy
-  ```
-
-To install a specific version 'X.Y.Z' different from the default one:
-
-  ```shell
-  sudo make deploy RELEASE_VERSION=X.Y.Z
-  ```

TODO.md

@@ -0,0 +1,9 @@
+* [x] Support versioning
+* [x] Test use of `plpy` from python Package
+* [x] Add `pysal` etc. dependencies
+* [x] Define documentation practices (general, per extension/package?)
+* [x] Add initial function set (WIP)
+* Unify style of function comments
+* [x] Add integration tests
+* Make target to open a new version development (create symlinks, etc.)
+* [x] Should add cartodb ext. as a dependency?

check-compatibility.sh

@@ -1,108 +0,0 @@
-#!/bin/bash
-
-export PGUSER=postgres
-
-DBNAME=crankshaft_compatcheck
-
-function die {
-    echo $1
-    exit -1
-}
-
-# Create fresh DB
-psql -c "CREATE DATABASE $DBNAME;" || die "Could not create DB"
-
-# Hook for cleanup
-function cleanup {
-    psql -c "DROP DATABASE IF EXISTS crankshaft_compatcheck;"
-}
-trap cleanup EXIT
-
-# Deploy previous release
-(cd src/py && sudo make deploy RUN_OPTIONS="--no-deps") || die "Could not deploy python extension"
-(cd src/pg && sudo make deploy) || die " Could not deploy last release"
-psql -c "SELECT * FROM pg_available_extension_versions WHERE name LIKE 'crankshaft';"
-
-# Install in the fresh DB
-psql $DBNAME <<'EOF'
--- Install dependencies
-CREATE EXTENSION plpythonu;
-CREATE EXTENSION postgis VERSION '2.2.2';
-
--- Create role publicuser if it does not exist
-DO
-$$
-BEGIN
-   IF NOT EXISTS (
-      SELECT *
-      FROM   pg_catalog.pg_user
-      WHERE  usename = 'publicuser') THEN
-
-      CREATE ROLE publicuser LOGIN;
-   END IF;
-END
-$$ LANGUAGE plpgsql;
-
--- Install the default version
-CREATE EXTENSION crankshaft;
-\dx
-EOF
-
-# Save public function signatures
-psql $DBNAME <<'EOF'
-CREATE TABLE release_function_signatures AS
-  SELECT
-    p.proname as name,
-    pg_catalog.pg_get_function_result(p.oid) as result_type,
-    pg_catalog.pg_get_function_arguments(p.oid) as arguments,
-   CASE
-    WHEN p.proisagg THEN 'agg'
-    WHEN p.proiswindow THEN 'window'
-    WHEN p.prorettype = 'pg_catalog.trigger'::pg_catalog.regtype THEN 'trigger'
-    ELSE 'normal'
-   END as type
-  FROM pg_catalog.pg_proc p
-       LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
-  WHERE
-       n.nspname = 'cdb_crankshaft'
-       AND p.proname LIKE 'cdb_%'
-  ORDER BY 1, 2, 4;
-EOF
-
-# Deploy current dev branch
-make clean-dev || die "Could not clean dev files"
-sudo make install || die "Could not deploy current dev branch"
-
-# Check it can be upgraded
-psql $DBNAME -c "ALTER EXTENSION crankshaft update to 'dev';" || die "Cannot upgrade to dev version"
-
-# Check against saved public function signatures
-psql $DBNAME <<'EOF'
-CREATE TABLE dev_function_signatures AS
-  SELECT
-    p.proname as name,
-    pg_catalog.pg_get_function_result(p.oid) as result_type,
-    pg_catalog.pg_get_function_arguments(p.oid) as arguments,
-   CASE
-    WHEN p.proisagg THEN 'agg'
-    WHEN p.proiswindow THEN 'window'
-    WHEN p.prorettype = 'pg_catalog.trigger'::pg_catalog.regtype THEN 'trigger'
-    ELSE 'normal'
-   END as type
-  FROM pg_catalog.pg_proc p
-       LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
-  WHERE
-       n.nspname = 'cdb_crankshaft'
-       AND p.proname LIKE 'cdb_%'
-  ORDER BY 1, 2, 4;
-EOF
-
-echo "Functions in development not in latest release (ok):"
-psql $DBNAME -c "SELECT * FROM dev_function_signatures EXCEPT SELECT * FROM release_function_signatures;"
-
-echo "Functions in latest release not in development (compat issue):"
-psql $DBNAME -c "SELECT * FROM release_function_signatures EXCEPT SELECT * FROM dev_function_signatures;"
-
-# Fail if there's a signature mismatch / missing functions
-psql $DBNAME -c "SELECT * FROM release_function_signatures EXCEPT SELECT * FROM dev_function_signatures;" | fgrep '(0 rows)' \
-    || die "Function signatures changed"

check-up-to-date-with-master.sh

@@ -1,24 +0,0 @@
-#!/bin/bash
-
-CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD)
-
-if [[ "$CURRENT_BRANCH" == "master" || "$CURRENT_BRANCH" == "HEAD" ]]
-then
-    echo "master branch or detached HEAD"
-    exit 0
-fi
-
-# Add remote-master
-git remote add -t master remote-master https://github.com/CartoDB/crankshaft.git
-
-# Fetch master reference
-git fetch --depth=1 remote-master master
-
-# Compare HEAD with master
-# NOTE: travis by default uses --depth=50 so we are actually checking that the tip
-# of the branch is no more than 50 commits away from master as well.
-git rev-list HEAD | grep $(git rev-parse remote-master/master) ||
-    { echo "Your branch is not up to date with latest release";
-      echo "Please update it by running the following:";
-      echo "    git fetch && git merge origin/develop";
-      false; }

doc/02_moran.md

@@ -1,185 +0,0 @@
-## Areas of Interest Functions
-
-### CDB_AreasOfInterestLocal(subquery text, column_name text)
-
-This function classifies your data as being part of a cluster, as an outlier, or not part of a pattern based the significance of a classification. The classification happens through an autocorrelation statistic called Local Moran's I.
-
-#### Arguments
-
-| Name | Type | Description |
-|------|------|-------------|
-| subquery | TEXT | SQL query that exposes the data to be analyzed (e.g., `SELECT * FROM interesting_table`). This query must have the geometry column name `the_geom` and id column name `cartodb_id` unless otherwise specified in the input arguments |
-| column_name | TEXT | Name of column (e.g., should be `'interesting_value'` instead of `interesting_value` without single quotes) used for the analysis. |
-| weight type (optional) | TEXT | Type of weight to use when finding neighbors. Currently available options are 'knn' (default) and 'queen'. Read more about weight types in [PySAL's weights documentation](https://pysal.readthedocs.io/en/v1.11.0/users/tutorials/weights.html). |
-| num_ngbrs (optional) | INT | Number of neighbors if using k-nearest neighbors weight type. Defaults to 5. |
-| permutations (optional) | INT | Number of permutations to check against a random arrangement of the values in `column_name`. This influences the accuracy of the output field `significance`. Defaults to 99. |
-| geom_col (optional) | TEXT | The column name for the geometries. Defaults to `'the_geom'` |
-| id_col (optional) | TEXT | The column name for the unique ID of each geometry/value pair. Defaults to `'cartodb_id'`. |
-
-#### Returns
-
-A table with the following columns.
-
-| Column Name | Type | Description |
-|-------------|------|-------------|
-| moran | NUMERIC | Value of Moran's I (spatial autocorrelation measure) for the geometry with id of `rowid` |
-| quads | TEXT | Classification of geometry. Result is one of 'HH' (a high value with neighbors high on average), 'LL' (opposite of 'HH'), 'HL' (a high value surrounded by lows on average), and 'LH' (opposite of 'HL'). Null values are returned when nulls exist in the original data. |
-| significance | NUMERIC | The statistical significance (from 0 to 1) of a cluster or outlier classification. Lower numbers are more significant. |
-| rowid | INT | Row id of the values which correspond to the input rows. |
-| vals | NUMERIC | Values from `'column_name'`. |
-
-
-#### Example Usage
-
-```sql
-SELECT
-  c.the_geom,
-  aoi.quads,
-  aoi.significance,
-  c.num_cyclists_per_total_population
-FROM CDB_AreasOfInterestLocal('SELECT * FROM commute_data'
-                                 'num_cyclists_per_total_population') As aoi
-JOIN commute_data As c
-ON c.cartodb_id = aoi.rowid;
-```
-
-### CDB_AreasOfInterestGlobal(subquery text, column_name text)
-
-This function identifies the extent to which geometries cluster (the groupings of geometries with similarly high or low values relative to the mean) or form outliers (areas where geometries have values opposite of their neighbors). The output of this function gives values between -1 and 1 as well as a significance of that classification. Values close to 0 mean that there is little to no distribution of values as compared to what one would see in a randomly distributed collection of geometries and values.
-
-#### Arguments
-
-| Name | Type | Description |
-|------|------|-------------|
-| subquery | TEXT | SQL query that exposes the data to be analyzed (e.g., `SELECT * FROM interesting_table`). This query must have the geometry column name `the_geom` and id column name `cartodb_id` unless otherwise specified in the input arguments |
-| column_name | TEXT | Name of column (e.g., should be `'interesting_value'` instead of `interesting_value` without single quotes) used for the analysis. |
-| weight type (optional) | TEXT | Type of weight to use when finding neighbors. Currently available options are 'knn' (default) and 'queen'. Read more about weight types in [PySAL's weights documentation](https://pysal.readthedocs.io/en/v1.11.0/users/tutorials/weights.html). |
-| num_ngbrs (optional) | INT | Number of neighbors if using k-nearest neighbors weight type. Defaults to 5. |
-| permutations (optional) | INT | Number of permutations to check against a random arrangement of the values in `column_name`. This influences the accuracy of the output field `significance`. Defaults to 99. |
-| geom_col (optional) | TEXT | The column name for the geometries. Defaults to `'the_geom'` |
-| id_col (optional) | TEXT | The column name for the unique ID of each geometry/value pair. Defaults to `'cartodb_id'`. |
-
-#### Returns
-
-A table with the following columns.
-
-| Column Name | Type | Description |
-|-------------|------|-------------|
-| moran | NUMERIC | Value of Moran's I (spatial autocorrelation measure) for the entire dataset. Values closer to one indicate cluster, closer to -1 mean more outliers, and near zero indicates a random distribution of data. |
-| significance | NUMERIC | The statistical significance of the `moran` measure. |
-
-#### Examples
-
-```sql
-SELECT *
-FROM CDB_AreasOfInterestGlobal('SELECT * FROM commute_data', 'num_cyclists_per_total_population')
-```
-
-### CDB_AreasOfInterestLocalRate(subquery text, numerator_column text, denominator_column text)
-
-Just like `CDB_AreasOfInterestLocal`, this function classifies your data as being part of a cluster, as an outlier, or not part of a pattern based the significance of a classification. This function differs in that it calculates the classifications based on input `numerator` and `denominator` columns for finding the areas where there are clusters and outliers for the resulting rate of those two values.
-
-#### Arguments
-
-| Name | Type | Description |
-|------|------|-------------|
-| subquery | TEXT | SQL query that exposes the data to be analyzed (e.g., `SELECT * FROM interesting_table`). This query must have the geometry column name `the_geom` and id column name `cartodb_id` unless otherwise specified in the input arguments |
-| numerator | TEXT | Name of the numerator for forming a rate to be used in analysis. |
-| denominator | TEXT | Name of the denominator for forming a rate to be used in analysis. |
-| weight type (optional) | TEXT | Type of weight to use when finding neighbors. Currently available options are 'knn' (default) and 'queen'. Read more about weight types in [PySAL's weights documentation](https://pysal.readthedocs.io/en/v1.11.0/users/tutorials/weights.html). |
-| num_ngbrs (optional) | INT | Number of neighbors if using k-nearest neighbors weight type. Defaults to 5. |
-| permutations (optional) | INT | Number of permutations to check against a random arrangement of the values in `column_name`. This influences the accuracy of the output field `significance`. Defaults to 99. |
-| geom_col (optional) | TEXT | The column name for the geometries. Defaults to `'the_geom'` |
-| id_col (optional) | TEXT | The column name for the unique ID of each geometry/value pair. Defaults to `'cartodb_id'`. |
-
-#### Returns
-
-A table with the following columns.
-
-| Column Name | Type | Description |
-|-------------|------|-------------|
-| moran | NUMERIC | Value of Moran's I (spatial autocorrelation measure) for the geometry with id of `rowid` |
-| quads | TEXT | Classification of geometry. Result is one of 'HH' (a high value with neighbors high on average), 'LL' (opposite of 'HH'), 'HL' (a high value surrounded by lows on average), and 'LH' (opposite of 'HL'). Null values are returned when nulls exist in the original data. |
-| significance | NUMERIC | The statistical significance (from 0 to 1) of a cluster or outlier classification. Lower numbers are more significant. |
-| rowid | INT | Row id of the values which correspond to the input rows. |
-| vals | NUMERIC | Values from `'column_name'`. |
-
-
-#### Example Usage
-
-```sql
-SELECT
-  c.the_geom,
-  aoi.quads,
-  aoi.significance,
-  c.cyclists_per_total_population
-FROM CDB_AreasOfInterestLocalRate('SELECT * FROM commute_data'
-                                     'num_cyclists',
-                                     'total_population') As aoi
-JOIN commute_data As c
-ON c.cartodb_id = aoi.rowid;
-```
-
-### CDB_AreasOfInterestGlobalRate(subquery text, column_name text)
-
-This function identifies the extent to which geometries cluster (the groupings of geometries with similarly high or low values relative to the mean) or form outliers (areas where geometries have values opposite of their neighbors). The output of this function gives values between -1 and 1 as well as a significance of that classification. Values close to 0 mean that there is little to no distribution of values as compared to what one would see in a randomly distributed collection of geometries and values.
-
-#### Arguments
-
-| Name | Type | Description |
-|------|------|-------------|
-| subquery | TEXT | SQL query that exposes the data to be analyzed (e.g., `SELECT * FROM interesting_table`). This query must have the geometry column name `the_geom` and id column name `cartodb_id` unless otherwise specified in the input arguments |
-| numerator | TEXT | Name of the numerator for forming a rate to be used in analysis. |
-| denominator | TEXT | Name of the denominator for forming a rate to be used in analysis. |
-| weight type (optional) | TEXT | Type of weight to use when finding neighbors. Currently available options are 'knn' (default) and 'queen'. Read more about weight types in [PySAL's weights documentation](https://pysal.readthedocs.io/en/v1.11.0/users/tutorials/weights.html). |
-| num_ngbrs (optional) | INT | Number of neighbors if using k-nearest neighbors weight type. Defaults to 5. |
-| permutations (optional) | INT | Number of permutations to check against a random arrangement of the values in `column_name`. This influences the accuracy of the output field `significance`. Defaults to 99. |
-| geom_col (optional) | TEXT | The column name for the geometries. Defaults to `'the_geom'` |
-| id_col (optional) | TEXT | The column name for the unique ID of each geometry/value pair. Defaults to `'cartodb_id'`. |
-
-#### Returns
-
-A table with the following columns.
-
-| Column Name | Type | Description |
-|-------------|------|-------------|
-| moran | NUMERIC | Value of Moran's I (spatial autocorrelation measure) for the entire dataset. Values closer to one indicate cluster, closer to -1 mean more outliers, and near zero indicates a random distribution of data. |
-| significance | NUMERIC | The statistical significance of the `moran` measure. |
-
-#### Examples
-
-```sql
-SELECT *
-FROM CDB_AreasOfInterestGlobalRate('SELECT * FROM commute_data',          
-                                   'num_cyclists',
-                                   'total_population')
-```
-
-## Hotspot, Coldspot, and Outlier Functions
-
-These functions are convenience functions for extracting only information that you are interested in exposing based on the outputs of the `CDB_AreasOfInterest` functions. For instance, you can use `CDB_GetSpatialHotspots` to output only the classifications of `HH` and `HL`.
-
-### Non-rate functions
-
-#### CDB_GetSpatialHotspots
-This function's inputs and outputs exactly mirror `CDB_AreasOfInterestLocal` except that the outputs are filtered to be only 'HH' and 'HL' (areas of high values). For more information about this function's use, see `CDB_AreasOfInterestLocal`.
-
-#### CDB_GetSpatialColdspots
-This function's inputs and outputs exactly mirror `CDB_AreasOfInterestLocal` except that the outputs are filtered to be only 'LL' and 'LH' (areas of low values). For more information about this function's use, see `CDB_AreasOfInterestLocal`.
-
-#### CDB_GetSpatialOutliers
-This function's inputs and outputs exactly mirror `CDB_AreasOfInterestLocal` except that the outputs are filtered to be only 'HL' and 'LH' (areas where highs or lows are surrounded by opposite values on average). For more information about this function's use, see `CDB_AreasOfInterestLocal`.
-
-### Rate functions
-
-#### CDB_GetSpatialHotspotsRate
-
-This function's inputs and outputs exactly mirror `CDB_AreasOfInterestLocalRate` except that the outputs are filtered to be only 'HH' and 'HL' (areas of high values). For more information about this function's use, see `CDB_AreasOfInterestLocalRate`.
-
-#### CDB_GetSpatialColdspotsRate
-
-This function's inputs and outputs exactly mirror `CDB_AreasOfInterestLocalRate` except that the outputs are filtered to be only 'LL' and 'LH' (areas of low values). For more information about this function's use, see `CDB_AreasOfInterestLocalRate`.
-
-#### CDB_GetSpatialOutliersRate
-
-This function's inputs and outputs exactly mirror `CDB_AreasOfInterestLocalRate` except that the outputs are filtered to be only 'HL' and 'LH' (areas where highs or lows are surrounded by opposite values on average). For more information about this function's use, see `CDB_AreasOfInterestLocalRate`.

doc/04_markov.md

@@ -1,47 +0,0 @@
-## Spatial Markov
-
-### CDB_SpatialMarkovTrend(subquery text, column_names text array)
-
-This function takes time series data associated with geometries and outputs likelihoods that the next value of a geometry will move up, down, or stay static as compared to the most recent measurement. For more information, read about [Spatial Dynamics in PySAL](https://pysal.readthedocs.io/en/v1.11.0/users/tutorials/dynamics.html).
-
-#### Arguments
-
-| Name | Type | Description |
-|------|------|-------------|
-| subquery | TEXT | SQL query that exposes the data to be analyzed (e.g., `SELECT * FROM real_estate_history`). This query must have the geometry column name `the_geom` and id column name `cartodb_id` unless otherwise specified in the input arguments |
-| column_names | TEXT Array | Names of column that form the history of measurements for the geometries (e.g., `Array['y2011', 'y2012', 'y2013', 'y2014', 'y2015', 'y2016']`). |
-| num_classes (optional) | INT | Number of quantile classes to separate data into. |
-| weight type (optional) | TEXT | Type of weight to use when finding neighbors. Currently available options are 'knn' (default) and 'queen'. Read more about weight types in [PySAL's weights documentation](https://pysal.readthedocs.io/en/v1.11.0/users/tutorials/weights.html). |
-| num_ngbrs (optional) | INT | Number of neighbors if using k-nearest neighbors weight type. Defaults to 5. |
-| permutations (optional) | INT | Number of permutations to check against a random arrangement of the values in `column_name`. This influences the accuracy of the output field `significance`. Defaults to 99. |
-| geom_col (optional) | TEXT | The column name for the geometries. Defaults to `'the_geom'` |
-| id_col (optional) | TEXT | The column name for the unique ID of each geometry/value pair. Defaults to `'cartodb_id'`. |
-
-#### Returns
-
-A table with the following columns.
-
-| Column Name | Type | Description |
-|-------------|------|-------------|
-| trend | NUMERIC | The probability that the measure at this location will move up (a positive number) or down (a negative number) |
-| trend_up | NUMERIC | The probability that a measure will move up in subsequent steps of time |
-| trend_down | NUMERIC | The probability that a measure will move down in subsequent steps of time |
-| volatility | NUMERIC | A measure of the variance of the probabilities returned from the Spatial Markov predictions |
-| rowid | NUMERIC | id of the row that corresponds to the `id_col` (by default `cartodb_id` of the input rows)  |
-
-
-#### Example Usage
-
-```sql
-SELECT
-  c.cartodb_id,
-  c.the_geom,
-  m.trend,
-  m.trend_up,
-  m.trend_down,
-  m.volatility
-FROM CDB_SpatialMarkovTrend('SELECT * FROM nyc_real_estate'
-                            Array['m03y2009','m03y2010','m03y2011','m03y2012','m03y2013','m03y2014','m03y2015','m03y2016']) As m
-JOIN nyc_real_estate As c
-ON c.cartodb_id = m.rowid;
-```

doc/04_pyAgg.md

@@ -1,23 +0,0 @@
-## PyAgg Helper Function 
-
-### CDB_pyAgg (columns Numeric[])
-
-Currently it's not possible to pass a multidiemensional array between plpsql and plpythonu. This function aims to
-help fix that by aggergating the columns provided in the argument across rows in to a rows * columns + 1 length 1D array. The first element of the array is the array\_length of the columns argument so that python can reconstruct 
-the 2D array. 
-
-#### Arguments
-
-| Name | Type | Description |
-|------|------|-------------|
-| columns | NUMERIC[] | The columns to aggregate across rows|
-
-#### Returns
-
-A table with the following columns.
-
-| Column Name | Type | Description |
-|-------------|------|-------------|
-| result | NUMERIC[] | An columns * rows + 1 array where the first entry is the no of columns|
-
-

doc/07_gravity.md

@@ -1,78 +0,0 @@
-## Gravity Model
-
-Gravity Models are derived from Newton's Law of Gravity and are used to predict the interaction between a group of populated areas (sources) and a specific target among a group of potential targets, in terms of an attraction factor (weight)
-
-**CDB_Gravity** is based on the model defined in *Huff's Law of Shopper attraction (1963)*
-
-### CDB_Gravity(t_id bigint[], t_geom geometry[], t_weight numeric[], s_id bigint[], s_geom geometry[], s_pop numeric[], target bigint, radius integer, minval numeric DEFAULT -10e307)
-
-#### Arguments
-
-| Name | Type | Description |
-|------|------|-------------|
-| t_id     | bigint[]    | Array of targets ID |
-| t_geom   | geometry[]  | Array of targets' geometries |
-| t_weight | numeric[]   | Array of targets's weights |
-| s_id     | bigint[]    | Array of sources ID |
-| s_geom   | geometry[]  | Array of sources' geometries |
-| s_pop    | numeric[]   | Array of sources's population |
-| target   | bigint      | ID of the target under study |
-| radius   | integer     | Radius in meters around the target under study that will be taken into account|
-| minval (optional)   | numeric     | Lowest accepted value of weight, defaults to numeric min_value |
-
-### CDB_Gravity( target_query text, weight_column text, source_query text, pop_column text, target bigint, radius integer, minval numeric DEFAULT -10e307)
-
-#### Arguments
-
-| Name | Type | Description |
-|------|------|-------------|
-| target_query     | text    | Query that defines targets |
-| weight_column   | text  | Column name of weights |
-| source_query     | text    | Query that defines sources |
-| pop_column   | text  | Column name of population |
-| target   | bigint      | cartodb_id of the target under study |
-| radius   | integer     | Radius in meters around the target under study that will be taken into account|
-| minval (optional)   | numeric     | Lowest accepted value of weight, defaults to numeric min_value |
-
-
-### Returns
-
-| Column Name | Type | Description |
-|-------------|------|-------------|
-| the_geom  | geometry | Geometries of the sources within the radius |
-| source_id | bigint  | ID of the source |
-| target_id | bigint  | Target ID from input |
-| dist      | numeric | Distance in meters source to target (if not points, distance between centroids) |
-| h         | numeric | Probability of patronage |
-| hpop      | numeric | Patronaging population |
-
-
-#### Example Usage
-
-```sql
-with t as (
-SELECT
-    array_agg(cartodb_id::bigint) as id,
-    array_agg(the_geom) as g,
-    array_agg(coalesce(gla,0)::numeric) as w
-FROM
-    abel.centros_comerciales_de_madrid
-WHERE not no_cc
-),
-s as (
-SELECT
-    array_agg(cartodb_id::bigint) as id,
-    array_agg(center) as g,
-    array_agg(coalesce(t1_1, 0)::numeric) as p
-FROM
-    sscc_madrid
-)
-select
-    g.the_geom,
-    trunc(g.h,2) as h,
-    round(g.hpop) as hpop,
-    trunc(g.dist/1000,2) as dist_km
-FROM t, s, CDB_Gravity1(t.id, t.g, t.w, s.id, s.g, s.p, newmall_ID, 100000, 5000) g
-```
-
-

doc/08_interpolation.md

@@ -1,54 +0,0 @@
-## Spacial interpolation
-
-Function to interpolate a numeric attribute of a point in a scatter dataset of points, using one of three methos:
-
-* [Nearest neighbor(s)](https://en.wikipedia.org/wiki/Nearest-neighbor_interpolation)
-* [Barycentric](https://en.wikipedia.org/wiki/Barycentric_coordinate_system)
-* [IDW](https://en.wikipedia.org/wiki/Inverse_distance_weighting)
-
-### CDB_SpatialInterpolation (query text, point geometry, method integer DEFAULT 1, p1 integer DEFAULT 0, ps integer DEFAULT 0)
-
-#### Arguments
-
-| Name | Type | Description |
-|------|------|-------------|
-| query   | text | query that returns at least `the_geom` and a numeric value as `attrib` |
-| point   | geometry | The target point to calc the value |
-| method   | integer     | 0:nearest neighbor, 1: barycentric, 2: IDW|
-| p1   | integer     | limit the number of neighbors, IDW: 0->no limit, NN: 0-> closest one|
-| p2   | integer     | IDW: order of distance decay, 0-> order 1|
-
-### CDB_SpatialInterpolation (geom geometry[], values numeric[], point geometry, method integer DEFAULT 1, p1 integer DEFAULT 0, ps integer DEFAULT 0)
-
-#### Arguments
-
-| Name | Type | Description |
-|------|------|-------------|
-| geom   | geometry[]  | Array of points's geometries |
-| values | numeric[]   | Array of points' values for the param under study|
-| point   | geometry | The target point to calc the value |
-| method   | integer     | 0:nearest neighbor, 1: barycentric, 2: IDW|
-| p1   | integer     | limit the number of neighbors, IDW: 0->no limit, NN: 0-> closest one|
-| p2   | integer     | IDW: order of distance decay, 0-> order 1|
-
-### Returns
-
-| Column Name | Type | Description |
-|-------------|------|-------------|
-| value  | numeric | Interpolated value at the given point, `-888.888` if the given point is out of the boundaries of the source points set |
-
-Default values:
-* -888.888: when using Barycentric, the target point is out of the realm of the input points
-* -777.777: asking for a method not available
-
-#### Example Usage
-
-```sql
-with a as (
-    select
-        array_agg(the_geom) as geomin,
-        array_agg(temp::numeric) as colin
-    from table_4804232032
-)
-SELECT CDB_SpatialInterpolation(geomin, colin, CDB_latlng(41.38, 2.15),1) FROM a;
-```

doc/09_voronoi.md

@@ -1,38 +0,0 @@
-## Voronoi
-
-Function to construct the [Voronoi Diagram](https://en.wikipedia.org/wiki/Voronoi_diagram) from a dataset of scatter points, clipped to the significant area
-
-PostGIS wil include this in future versions ([doc for dev branch](http://postgis.net/docs/manual-dev/ST_Voronoi.html)) and will perform faster for sure, but in the meantime...
-
-
-### CDB_Voronoi (geom geometry[], buffer numeric DEFAULT 0.5, tolerance numeric DEFAULT 1e-9)
-
-#### Arguments
-
-| Name | Type | Description |
-|------|------|-------------|
-| geom   | geometry[]  | Array of points's geometries |
-| buffer | numeric   | enlargment ratio for the envelope area used for the restraints|
-| tolerance   | numeric |  Delaunay tolerance, optional |
-
-### Returns
-
-| Column Name | Type | Description |
-|-------------|------|-------------|
-| geom  | geometry collection | Collection of polygons of the Voronoi cells|
-
-
-#### Example Usage
-
-```sql
-WITH a AS (
-    SELECT
-    ARRAY[ST_GeomFromText('POINT(2.1744 41.403)', 4326),ST_GeomFromText('POINT(2.1228 41.380)', 4326),ST_GeomFromText('POINT(2.1511 41.374)', 4326),ST_GeomFromText('POINT(2.1528 41.413)', 4326),ST_GeomFromText('POINT(2.165 41.391)', 4326),ST_GeomFromText('POINT(2.1498 41.371)', 4326),ST_GeomFromText('POINT(2.1533 41.368)', 4326),ST_GeomFromText('POINT(2.131386 41.41399)', 4326)] AS geomin
-)
-SELECT
-    st_transform(
-    (st_dump(CDB_voronoi(geomin, 0.2, 1e-9)
-    )).geom
-        , 3857) as the_geom_webmercator
-FROM a;
-```

doc/11_kmeans.md

@@ -1,62 +0,0 @@
-## K-Means Functions
-
-### CDB_KMeans(subquery text, no_clusters INTEGER)
-
-This function attempts to find n clusters within the input data. It will return a table to CartoDB ids and 
-the number of the cluster each point in the input was assigend to.
-
-
-#### Arguments
-
-| Name | Type | Description |
-|------|------|-------------|
-| subquery | TEXT | SQL query that exposes the data to be analyzed (e.g., `SELECT * FROM interesting_table`). This query must have the geometry column name `the_geom` and id column name `cartodb_id` unless otherwise specified in the input arguments |
-| no\_clusters | INTEGER | The number of clusters to try and find |
-
-#### Returns
-
-A table with the following columns.
-
-| Column Name | Type | Description |
-|-------------|------|-------------|
-| cartodb\_id | INTEGER | The CartoDB id of the row in the input table.|
-| cluster\_no | INTEGER | The cluster that this point belongs to. |
-
-
-#### Example Usage
-
-```sql
-SELECT 
-    customers.*, 
-    km.cluster_no 
-    FROM cdb_crankshaft.CDB_Kmeans('SELECT * from customers' , 6) km, customers_3
-    WHERE customers.cartodb_id = km.cartodb_id
-```
-
-### CDB_WeightedMean(subquery text, weight_column text, category_column text)
-
-Function that computes the weighted centroid of a number of clusters by some weight column.
-
-### Arguments 
-
-| Name | Type | Description |
-|------|------|-------------|
-| subquery | TEXT | SQL query that exposes the data to be analyzed (e.g., `SELECT * FROM interesting_table`). This query must have the geometry column and the columns specified as the weight and category columns|
-| weight\_column | TEXT | The name of the column to use as a weight |
-| category\_column | TEXT | The name of the column to use as a category |
-
-### Returns 
-
-A table with the following columns.
-
-| Column Name | Type | Description |
-|-------------|------|-------------|
-| the\_geom | GEOMETRY | A point for the weighted cluster center |
-| class | INTEGER | The cluster class | 
-
-### Example Usage 
-
-```sql 
-SELECT ST_TRANSFORM(the_geom, 3857) as the_geom_webmercator, class 
-FROM cdb_weighted_mean('SELECT *, customer_value FROM customers','customer_value','cluster_no')
-```

doc/12_segmentation.md

@@ -1,83 +0,0 @@
-
-## Segmentation Functions
-
-### CDB_CreateAndPredictSegment(query TEXT, variable_name TEXT, target_query TEXT)
-
-This function trains a [Gradient Boosting](http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingRegressor.html) model to attempt to predict the target data and then generates predictions for new data.  
-
-#### Arguments
-
-| Name | Type | Description |
-|------|------|-------------|
-| query | TEXT | The input query to train the algorithm, which should have both the variable of interest and the features that will be used to predict it |
-| variable\_name| TEXT | Specify the variable in the query to predict, all other columns are assumed to be features |
-| target\_table | TEXT | The query which returns the `cartodb_id` and features for the rows your would like to predict the target variable for |
-| n\_estimators (optional) | INTEGER DEFAULT 1200 | Number of estimators to be used. Values should be between 1 and x. |
-| max\_depth (optional) | INTEGER DEFAULT 3 | Max tree depth. Values should be between 1 and n. |
-| subsample (optional)  | DOUBLE PRECISION DEFAULT 0.5 | Subsample parameter for GradientBooster. Values should be within the range 0 to 1. |
-| learning\_rate (optional) | DOUBLE PRECISION DEFAULT 0.01 | Learning rate for the GradientBooster. Values should be between 0 and 1 (??) |
-| min\_samples\_leaf (optional) | INTEGER DEFAULT 1 | Minimum samples to use per leaf. Values should range from x to y |
-
-#### Returns
-
-A table with the following columns.
-
-| Column Name | Type | Description |
-|-------------|------|-------------|
-| cartodb\_id | INTEGER | The CartoDB id of the row in the target\_query |
-| prediction | NUMERIC | The predicted value of the variable of interest |
-| accuracy | NUMERIC | The mean squared accuracy of the model. |
-
-#### Example Usage
-
-```sql
-SELECT * from cdb_crankshaft.CDB_CreateAndPredictSegment(
-'SELECT agg, median_rent::numeric, male_pop::numeric, female_pop::numeric FROM late_night_agg',
-'agg',
-'SELECT row_number() OVER () As cartodb_id, median_rent, male_pop, female_pop FROM ml_learning_ny');                               
-```
-
-### CDB_CreateAndPredictSegment(target numeric[], train_features numeric[], prediction_features numeric[], prediction_ids numeric[])
-
-This function trains a [Gradient Boosting](http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.GradientBoostingRegressor.html) model to attempt to predict the target data and then generates predictions for new data.  
-
-
-#### Arguments
-
-| Name | Type | Description |
-|------|------|-------------|
-| target | numeric[] | An array of target values of the variable you want to predict|
-| train\_features| numeric[] | 1D array of length n features \* n\_rows + 1 with the first entry in the array being the number of features in each row. These are the features the model will be trained on. CDB\_Crankshaft.CDB_pyAgg(Array[feature1, feature2, feature3]::numeric[]) can be used to construct this. |
-| prediction\_features | numeric[] | 1D array of length nfeatures\* n\_rows\_ + 1 with the first entry in the array being the number of features in each row. These are the features that will be used to predict the target variable  CDB\_Crankshaft.CDB\_pyAgg(Array[feature1, feature2, feature3]::numeric[]) can be used to construct this.  |
-| prediction\_ids | numeric[] | 1D array of length n\_rows with the ids that can use used to re-join the data with inputs |
-| n\_estimators (optional) | INTEGER DEFAULT 1200 | Number of estimators to be used |
-| max\_depth (optional) | INTEGER DEFAULT 3 | Max tree depth |
-| subsample (optional)  | DOUBLE PRECISION DEFAULT 0.5 | Subsample parameter for GradientBooster|
-| learning\_rate (optional) | DOUBLE PRECISION DEFAULT 0.01 | Learning rate for the GradientBooster |
-| min\_samples\_leaf (optional) | INTEGER DEFAULT 1 | Minimum samples to use per leaf |
-
-
-#### Returns
-
-A table with the following columns.
-
-| Column Name | Type | Description |
-|-------------|------|-------------|
-| cartodb\_id | INTEGER | The CartoDB id of the row in the target\_query |
-| prediction | NUMERIC | The predicted value of the variable of interest |
-| accuracy | NUMERIC | The mean squared accuracy of the model. |
-
-#### Example Usage
-
-```sql
-WITH training As (
-    SELECT array_agg(agg) As target,
-           cdb_crankshaft.CDB_PyAgg(Array[median_rent, male_pop, female_pop]::Numeric[]) As features
-    FROM late_night_agg),
-target AS (
-    SELECT cdb_crankshaft.CDB_PyAgg(Array[median_rent, male_pop, female_pop]::Numeric[]) As features,
-     array_agg(cartodb_id) As cartodb_ids FROM late_night_agg)  
-
-SELECT cdb_crankshaft.CDB_CreateAndPredictSegment(training.target, training.features, target.features, target.cartodb_ids)
-FROM training, target;
-```

doc/13_PIA.md

@@ -1,33 +0,0 @@
-## Pole of inaccessibility (PIA)
-
-Function to find the [PIA](https://en.wikipedia.org/wiki/Pole_of_inaccessibility) from a given polygon and tolerance, following the quadtree approach by [Vladimir Agafonkin](https://github.com/mourner) described [here](https://github.com/mapbox/polylabel)
-
-
-
-### CDB_PIA (polygon geometry, tolerance numeric DEFAULT 1.0)
-
-#### Arguments
-
-| Name | Type | Description |
-|------|------|-------------|
-| polygon   | geometry  | Target polygon |
-| tolerance   | numeric | Threshold to decide to take a cell into account |
-
-### Returns
-
-| Column Name | Type | Description |
-|-------------|------|-------------|
-| point  | geometry| Pole of inaccessibility |
-
-
-#### Example Usage
-
-```sql
-with a as(
- select st_geomfromtext('POLYGON((-432540.453078056 4949775.20452642,-432329.947920966 4951361.232584,-431245.028163694 4952223.31516671,-429131.071033529 4951768.00415574,-424622.07505895 4952843.13503987,-423688.327170174 4953499.20752423,-424086.294349759 4954968.38274191,-423068.388925945 4954378.63345336,-423387.653225542 4953355.67417084,-420594.869840519 4953781.00230592,-416026.095299382 4951484.06849063,-412483.018546414 4951024.5410983,-410490.399661215 4954502.24032205,-408186.197521284 4956398.91417441,-407627.262358013 4959300.94633864,-406948.770061627 4959874.85407739,-404949.583326472 4959047.74518163,-402570.908447199 4953743.46829807,-400971.358683991 4952193.11680804,-403533.488084088 4949649.89857885,-406335.177028373 4950193.19571096,-407790.456731515 4952391.46015616,-412060.672398345 4950381.2389307,-410716.93482498 4949156.7509561,-408464.162289794 4943912.8940387,-409350.599394983 4942819.84896006,-408087.791091424 4942451.6711778,-407274.045613725 4940572.4807777,-404446.196589102 4939976.71501489,-402422.964843936 4940450.3670813,-401010.654464241 4939054.8061663,-397647.247369412 4940679.80737878,-395658.413346901 4940528.84765185,-395536.852462953 4938829.79565997,-394268.923462818 4938003.7277717,-393388.720249116 4934757.80596815,-392393.301362444 4934326.71675815,-392573.527618037 4932323.40974412,-393464.640141837 4931903.10653605,-393085.597275686 4931094.7353605,-398426.261165985 4929156.87541607,-398261.174361137 4926238.00816416,-394045.059966834 4925765.18668498,-392982.960705174 4926391.81893628,-393090.272694301 4927176.84692181,-391648.240010564 4924626.06386961,-391889.914625075 4923086.14787613,-394345.177314013 4923235.086036,-395550.878718795 4917812.79243978,-399009.463978251 4912927.7157945,-398948.794855767 4911941.91010796,-398092.636652078 4911806.57392519,-401991.601817112 4911722.9204501,-406225.972607907 4914505.47286319,-411104.994569885 4912569.26941163,-412925.513522316 4913030.3608866,-414630.148884835 4914436.69169949,-414207.691417276 4919205.78028405,-418306.141109809 4917994.9580478,-424184.700779621 4918938.12432889,-426816.961458921 4923664.37379373,-420956.324227126 4923381.98014807,-420186.661267781 4924286.48693378,-420943.411166194 4926812.76394433,-419779.45457046 4928527.43466337,-419768.767899344 4930681.94459216,-421911.668097113 4930432.40620397,-423482.386112205 4933451.28047252,-427272.814773717 4934151.56473242,-427144.908678797 4939731.77191996,-428982.125554848 4940522.84445172,-428986.133056516 4942437.17281266,-431237.792396792 4947309.68284815,-432476.889648814 4947791.74800037,-432540.453078056 4949775.20452642))', 3857) as g
-),
-b as (
-    select ST_Transform(g, 4326) as g from a
-)
-SELECT st_astext(CDB_PIA(g)) from b;
-```

doc/14_densify.md

@@ -1,35 +0,0 @@
-## Densify function
-
-Iterative densification of a set of scattered points using Delaunay triangulation. The new points are located at the centroids of the grid cells and  have as assigned value the barycentric average value of the cell's vertex.
-
-### CDB_Densify(geomin geometry[], colin numeric[], iterations integer)
-
-#### Arguments
-
-| Name | Type | Description |
-|------|------|-------------|
-| geomin   | geometry[]  | Array of points geometries |
-| colin | numeric[]   | Array of points' values |
-| iterations   | integer     | Number of iterations |
-
-### Returns
-
-Returns a table object
-
-| Name | Type | Description |
-|------|------|-------------|
-| geomout   | geometry  | Geometries of new dataset of points|
-| colout | numeric   | Values of points|
-
-#### Example Usage
-
-```sql
-with data as (
-    select
-    ARRAY[7.0,8.0,1.0,2.0,3.0,5.0,6.0,4.0] as colin,
-    ARRAY[ST_GeomFromText('POINT(2.1744 41.4036)'),ST_GeomFromText('POINT(2.1228 41.3809)'),ST_GeomFromText('POINT(2.1511 41.3742)'),ST_GeomFromText('POINT(2.1528 41.4136)'),ST_GeomFromText('POINT(2.165 41.3917)'),ST_GeomFromText('POINT(2.1498 41.3713)'),ST_GeomFromText('POINT(2.1533 41.3683)'),ST_GeomFromText('POINT(2.131386 41.413998)')] as geomin
-)
-select CDB_Densify(geomin, colin, 2) from data;
-```
-
-

doc/15_tinmap.md

@@ -1,36 +0,0 @@
-## TINMAP function
-
-Generates a fake contour map, in the form of a TIN map, from a set of scattered points.Depends on **CDB_Densify**.
-
-Its iterative nature lets the user smooth the final result as much as desired, but with a exponential time cost increase.
-
-### CDB_TINmap(geomin geometry[], colin numeric[], iterations integer)
-
-#### Arguments
-
-| Name | Type | Description |
-|------|------|-------------|
-| geomin   | geometry[]  | Array of points geometries |
-| colin | numeric[]   | Array of points' values |
-| iterations   | integer     | Number of iterations |
-
-### Returns
-
-Returns a table object
-
-| Name | Type | Description |
-|------|------|-------------|
-| geomout   | geometry  | Geometries of new dataset of polygons|
-| colout | numeric   | Values of each cell|
-
-#### Example Usage
-
-```sql
-with data as (
-    select
-    ARRAY[7.0,8.0,1.0,2.0,3.0,5.0,6.0,4.0] as colin,
-    ARRAY[ST_GeomFromText('POINT(2.1744 41.4036)'),ST_GeomFromText('POINT(2.1228 41.3809)'),ST_GeomFromText('POINT(2.1511 41.3742)'),ST_GeomFromText('POINT(2.1528 41.4136)'),ST_GeomFromText('POINT(2.165 41.3917)'),ST_GeomFromText('POINT(2.1498 41.3713)'),ST_GeomFromText('POINT(2.1533 41.3683)'),ST_GeomFromText('POINT(2.131386 41.413998)')] as geomin
-)
-select CDB_TINmap(geomin, colin, 2) from data;
-```
-

doc/19_contour.md

@@ -1,50 +0,0 @@
-## Contour maps
-
-Function to generate a contour map from an scatter dataset of points, using one of these three methods:
-
-* [Nearest neighbor](https://en.wikipedia.org/wiki/Nearest-neighbor_interpolation)
-* [Barycentric](https://en.wikipedia.org/wiki/Barycentric_coordinate_system)
-* [IDW](https://en.wikipedia.org/wiki/Inverse_distance_weighting)
-
-### CDB_Contour (geom geometry[], values numeric[], resolution integer, buffer numeric, method, classmethod integer, steps integer)
-
-#### Arguments
-
-| Name | Type | Description |
-|------|------|-------------|
-| geom   | geometry[]  | Array of points's geometries |
-| values | numeric[]   | Array of points' values for the param under study|
-| buffer   | numeric     | Value between 0 and 1 for spatial buffer of the set of points
-| method   | integer     | 0:nearest neighbor, 1: barycentric, 2: IDW|
-| classmethod   | integer     | 0:equals, 1: heads&tails, 2:jenks, 3:quantiles |
-| steps   | integer     | Number of steps in the classification|
-| max_time   | integer     | if <= 0: max processing time in seconds (smart resolution) , if >0: resolution in meters
-
-### Returns
-Returns a table object
-
-| Name | Type | Description |
-|------|------|-------------|
-| the_geom   | geometry  | Geometries of the classified contour map|
-| avg_value | numeric   | Avg value of the area|
-| min_value | numeric   | Min value of the area|
-| max_value | numeric   | Max value of the areal|
-| bin | integer   | Index of the class of the area|
-
-#### Example Usage
-
-```sql
-WITH a AS (
-    SELECT
-    ARRAY[800, 700, 600, 500, 400, 300, 200, 100]::numeric[] AS vals,
-    ARRAY[ST_GeomFromText('POINT(2.1744 41.403)',4326),ST_GeomFromText('POINT(2.1228 41.380)',4326),ST_GeomFromText('POINT(2.1511 41.374)',4326),ST_GeomFromText('POINT(2.1528 41.413)',4326),ST_GeomFromText('POINT(2.165 41.391)',4326),ST_GeomFromText('POINT(2.1498 41.371)',4326),ST_GeomFromText('POINT(2.1533 41.368)',4326),ST_GeomFromText('POINT(2.131386 41.41399)',4326)] AS g
-),
-b as(
-SELECT
-    foo.*
-FROM
-    a,
-    cdb_crankshaft.CDB_contour(a.g, a.vals,  0.0, 1, 3, 5, 60) foo
-)
-SELECT bin, avg_value from b order by bin;
-```

doc/docs_template.md

@@ -1,24 +0,0 @@
-
-## Name
-
-## Synopsis
-
-## Description
-
-Availability: v...
-
-## Examples
-
-```SQL
--- example of the function in use
-SELECT cdb_awesome_function(the_geom, 'total_pop')
-FROM table_name
-```
-
-## API Usage
-
-_asdf_
-
-## See Also
-
-_Other function pages_

pg/.gitignore

@@ -0,0 +1,3 @@
+regression.diffs
+regression.out
+results/

pg/Makefile

@@ -0,0 +1,30 @@
+# Makefile to generate the extension out of separate sql source files.
+# Once a version is released, it is not meant to be changed. E.g: once version 0.0.1 is out, it SHALL NOT be changed.
+
+EXTENSION    = crankshaft
+EXTVERSION   = $(shell grep default_version $(EXTENSION).control | sed -e "s/default_version[[:space:]]*=[[:space:]]*'\([^']*\)'/\1/")
+
+# The new version to be generated from templates
+NEW_EXTENSION_ARTIFACT = $(EXTENSION)--$(EXTVERSION).sql
+
+# DATA is a special variable used by postgres build infrastructure
+# These are the files to be installed in the server shared dir,
+# for installation from scratch, upgrades and downgrades.
+# @see http://www.postgresql.org/docs/current/static/extend-pgxs.html
+DATA =  $(NEW_EXTENSION_ARTIFACT)
+
+SOURCES_DATA_DIR = sql/$(EXTVERSION)
+SOURCES_DATA = $(wildcard sql/$(EXTVERSION)/*.sql)
+
+# The extension installation artifacts are stored in the base subdirectory
+$(NEW_EXTENSION_ARTIFACT): $(SOURCES_DATA)
+	rm -f $@
+	cat $(SOURCES_DATA_DIR)/*.sql >> $@
+
+REGRESS = $(notdir $(basename $(wildcard test/$(EXTVERSION)/sql/*test.sql)))
+TEST_DIR = test/$(EXTVERSION)
+REGRESS_OPTS = --inputdir='$(TEST_DIR)' --outputdir='$(TEST_DIR)'
+
+PG_CONFIG = pg_config
+PGXS := $(shell $(PG_CONFIG) --pgxs)
+include $(PGXS)

pg/README.md

@@ -0,0 +1,7 @@
+
+# Running the tests:
+
+```
+sudo make install
+PGUSER=postgres make installcheck
+```

pg/crankshaft--0.0.1.sql

@@ -1,6 +1,3 @@
---DO NOT MODIFY THIS FILE, IT IS GENERATED AUTOMATICALLY FROM SOURCES
--- Complain if script is sourced in psql, rather than via CREATE EXTENSION
-\echo Use "CREATE EXTENSION crankshaft" to load this file. \quit
 -- Internal function.
 -- Set the seeds of the RNGs (Random Number Generators)
 -- used internally.
@@ -136,13 +133,4 @@ BEGIN
   RETURN ST_Collect(points);
 END;
 $$
-LANGUAGE plpgsql VOLATILE;
--- Make sure by default there are no permissions for publicuser
--- NOTE: this happens at extension creation time, as part of an implicit transaction.
--- REVOKE ALL PRIVILEGES ON SCHEMA cdb_crankshaft FROM PUBLIC, publicuser CASCADE;
-
--- Grant permissions on the schema to publicuser (but just the schema)
-GRANT USAGE ON SCHEMA cdb_crankshaft TO publicuser;
-
--- Revoke execute permissions on all functions in the schema by default
--- REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_crankshaft FROM PUBLIC, publicuser;
+LANGUAGE plpgsql VOLATILE

pg/crankshaft.control

@@ -1,5 +1,5 @@
 comment = 'CartoDB Spatial Analysis extension'
-default_version = '0.4.2'
-requires = 'plpythonu, postgis'
+default_version = '0.0.1'
+requires = 'plpythonu, postgis, cartodb'
 superuser = true
 schema = cdb_crankshaft

pg/doc/02_moran.md

@@ -0,0 +1,71 @@
+### Moran's I
+
+#### What is Moran's I and why is it significant for CartoDB?
+
+Moran's I is a geostatistical calculation which gives a measure of the global
+clustering and presence of outliers within the geographies in a map. Here global
+means over all of the geographies in a dataset. Imagine mapping the incidence
+rates of cancer in neighborhoods of a city. If there were areas covering several
+neighborhoods with abnormally low rates of cancer, those areas are positively
+spatially correlated with one another and would be considered a cluster. If
+there was a single neighborhood with a high rate but with all neighbors on
+average having a low rate, it would be considered a spatial outlier.
+
+While Moran's I gives a global snapshot, there are local indicators for
+clustering called Local Indicators of Spatial Autocorrelation. Clustering is a
+process related to autocorrelation -- i.e., a process that compares a
+geography's attribute to the attribute in neighbor geographies.
+
+For the example of cancer rates in neighborhoods, since these neighborhoods have
+a high value for rate of cancer, and all of their neighbors do as well, they are
+designated as "High High" or simply **HH**. For areas with multiple neighborhoods
+with low rates of cancer, they are designated as "Low Low" or **LL**. HH and LL
+naturally fit into the concept of clustering and are in the correlated
+variables.
+
+"Anticorrelated" geogs are in **LH** and **HL** regions -- that is, regions
+where a geog has a high value and it's neighbors, on average, have a low value
+(or vice versa). An example of this is a "gated community" or placement of a
+city housing project in a rich region. These deliberate developments have
+opposite median income as compared to the neighbors around them. They have a
+high (or low) value while their neighbors have a low (or high) value. They exist
+typically as islands, and in rare circumstances can extend as chains dividing
+**LL** or **HH**.
+
+Strong policies such as rent stabilization (probably) tend to prevent the
+clustering of high rent areas as they integrate middle class incomes. Luxury
+apartment buildings, which are a kind of gated community, probably tend to skew
+an area's median income upwards while housing projects have the opposite effect.
+What are the nuggets in the analysis?
+
+Two functions are available to compute Moran I statistics:
+
+* `cdb_moran_local` computes Moran I measures, quad classification and
+  significance values from numerial values associated to geometry entities
+  in an input table. The geometries should be contiguous polygons When
+  then `queen` `w_type` is used.
+* `cdb_moran_local_rate` computes the same statistics using a ratio between
+  numerator and denominator columns of a table.
+
+The parameters for `cdb_moran_local` are:
+
+* `table` name of the table that contains the data values
+* `attr` name of the column
+* `signficance` significance threshold for the quads values
+* `num_ngbrs` number of neighbors to consider (default: 5)
+* `permutations` number of random permutations for calculation of
+  pseudo-p values (default: 99)
+* `geom_column` number of the geometry column (default: "the_geom")
+* `id_col` PK column of the table (default: "cartodb_id")
+* `w_type` Weight types: can be "knn" for k-nearest neighbor weights
+  or "queen" for contiguity based weights.
+
+The function returns a table with the following columns:
+
+* `moran` Moran's value
+* `quads` quad classification ('HH', 'LL', 'HL', 'LH' or 'Not significant')
+* `significance` significance value
+* `ids` id of the corresponding record in the input table
+
+Function `cdb_moran_local_rate` only differs in that the `attr` input
+parameter is substituted by `numerator` and `denominator`.

pg/sql/0.0.1/02_moran.sql

@@ -1,12 +1,6 @@
+-- Moran's I
 CREATE OR REPLACE FUNCTION
-cdb_crankshaft._cdb_random_seeds (seed_value INTEGER) RETURNS VOID
-AS $$
-  from crankshaft import random_seeds
-  random_seeds.set_random_seeds(seed_value)
-$$ LANGUAGE plpythonu;
-
-CREATE OR REPLACE FUNCTION
-cdb_crankshaft.cdb_moran_local (
+  cdb_moran_local (
       t TEXT,
   	  attr TEXT,
   	  significance float DEFAULT 0.05,
@@ -22,8 +16,9 @@ AS $$
   return moran_local(t, attr, significance, num_ngbrs, permutations, geom_column, id_col, w_type)
 $$ LANGUAGE plpythonu;
 
+-- Moran's I Local Rate
 CREATE OR REPLACE FUNCTION
-cdb_crankshaft.cdb_moran_local_rate(t TEXT,
+  cdb_moran_local_rate(t TEXT,
 		 numerator TEXT,
 		 denominator TEXT,
 		 significance FLOAT DEFAULT 0.05,
@@ -38,7 +33,3 @@ AS $$
   # TODO: use named parameters or a dictionary
   return moran_local_rate(t, numerator, denominator, significance, num_ngbrs, permutations, geom_column, id_col, w_type)
 $$ LANGUAGE plpythonu;
-
-DROP FUNCTION IF EXISTS cdb_crankshaft.cdb_crankshaft_version();
-DROP FUNCTION IF EXISTS cdb_crankshaft._cdb_crankshaft_internal_version();
-DROP FUNCTION IF EXISTS cdb_crankshaft._cdb_crankshaft_activate_py();

pg/sql/0.0.1/04_dot_density.sql

@@ -51,4 +51,4 @@ BEGIN
   RETURN ST_Collect(points);
 END;
 $$
-LANGUAGE plpgsql VOLATILE;
+LANGUAGE plpgsql VOLATILE

pg/sql/0.0.1/population.sql

@@ -0,0 +1,138 @@
+-- Function to obtain an estimate of the population living inside
+-- an area (polygon) from the CartoDB Data Observatory
+CREATE OR REPLACE FUNCTION cdb_population(area geometry)
+RETURNS NUMERIC AS $$
+DECLARE
+  georef_column TEXT;
+  table_id TEXT;
+  tag_value TEXT;
+  table_name TEXT;
+  column_name TEXT;
+  population NUMERIC;
+BEGIN
+
+  -- Note: comments contain pseudo-code that should be implemented
+
+  -- Register metadata tables:
+  -- This would require super-user privileges
+  /*
+  SELECT cdb_add_remote_table('observatory', 'bmd_column_table');
+  SELECT cdb_add_remote_table('observatory', 'bmd_column_2_column');
+  SELECT cdb_add_remote_table('observatory', 'bmd_table');
+  SELECT cdb_add_remote_table('observatory', 'bmd_column_table');
+  SELECT cdb_add_remote_table('observatory', 'bmd_column_tag');
+  SELECT cdb_add_remote_table('observatory', 'bmd_tag');
+  */
+
+  tag_value := 'population';
+
+
+  -- Determine the georef column id to be used: it must have type 'geometry',
+  -- the maximum weight.
+  -- TODO: in general, multiple columns with maximal weight could be found;
+  -- we should use the timespan of the table to disambiguate (choose the
+  -- most recent). Also a rank of geometry columns should be introduced to
+  -- find select the greatest resolution available.
+  /*
+  WITH selected_tables AS (
+    -- Find tables that have population columns and cover the input area
+    SELECT tab.id AS id
+    FROM observatory.bmd_column col,
+         observatory.bmd_column_table coltab,
+         observatory.bmd_table tab,
+         observatory.bmd_tag tag,
+         observatory.bmd_column_tag coltag
+    WHERE coltab.column_id = col.id
+      AND coltab.table_id = tab.id
+      AND coltag.tag_id = tag.id
+      AND coltag.column_id = col.id
+      AND tag.name ILIKE tag_value
+      AND tab.id = table_id
+      AND tab.bounds && area;
+  )
+  SELECT
+    FROM bmd_column col
+    JOIN bmd_table tab ON col.table_id = tab.id
+    WHERE type = 'geometry'
+      AND tab.id IN (selected_tables)
+    ORDER BY weight DESC LIMIT 1;
+  */
+  georef_column := '"us.census.tiger".block_group_2013';
+
+  -- Now we will query the metadata to find which actual tables correspond
+  -- to this datasource and resolution/timespan
+  -- and choose the 'parent' or more general of them.
+  /*
+  SELECT from_table_geoid.id data_table_id
+  FROM observatory.bmd_column_table from_column_table_geoid,
+       observatory.bmd_column_table to_column_table_geoid,
+       observatory.bmd_column_2_column rel,
+       observatory.bmd_column_table to_column_table_geom,
+       observatory.bmd_table from_table_geoid,
+       observatory.bmd_table to_table_geoid,
+       observatory.bmd_table to_table_geom
+  WHERE from_column_table_geoid.column_id = to_column_table_geoid.column_id
+    AND to_column_table_geoid.column_id = rel.from_id
+    AND rel.reltype = 'geom_ref'
+    AND rel.to_id = to_column_table_geom.column_id
+    AND to_column_table_geom.column_id = georef_column
+    AND from_table_geoid.id = from_column_table_geoid.table_id
+    AND to_table_geoid.id = to_column_table_geoid.table_id
+    AND to_table_geom.id = to_column_table_geom.table_id
+    AND from_table_geoid.bounds && area
+  ORDER by from_table_geoid.timespan desc
+  INTO table_id;
+  */
+  table_id := '"us.census.acs".extract_2013_5yr_block_group';
+
+  -- Next will fetch the columns of that table that are tagged as population:
+  -- and get the more general one (not having a parent or denominator)
+  /*
+  WITH column_ids AS (
+    SELECT col.id AS id
+    FROM observatory.bmd_column col,
+         observatory.bmd_column_table coltab,
+         observatory.bmd_table tab,
+         observatory.bmd_tag tag,
+         observatory.bmd_column_tag coltag
+    WHERE coltab.column_id = col.id
+      AND coltab.table_id = tab.id
+      AND coltag.tag_id = tag.id
+      AND coltag.column_id = col.id
+      AND tag.name ILIKE tag_value
+      AND tab.id = table_id;
+  ),
+  excluded_column_ids AS (
+    SELECT from_id AS id
+    FROM observatory.bmd_column_2_column
+    WHERE from_id in (column_ids)
+      AND reltype in ('parent', 'denominator')
+      AND to_id in (column_ids)
+  ),
+  SELECT bmd_table.tablename, bmd_column_table.colname
+  FROM observatory.bmd_column_table,
+       observatory.bmd_table
+  WHERE bmd_column_table.table_id = bmd_table.id
+    AND bmd_column_table.column_id IN (column_ids)
+    AND NOT bmd_column_table.column_id IN (exclude_column_ids)
+  INTO (table_name, column_name);
+  */
+  table_name := 'us_census_acs2013_5yr_block_group';
+  column_name := 'total_pop';
+
+  -- Register the foreign table
+  -- This would require super-user privileges
+  -- SELECT cdb_add_remote_table('observatory', table_name);
+
+  -- Perform the query
+  SELECT cdb_crankshaft.cdb_overlap_sum(
+    area,
+    table_name,
+    column_name,
+    schema_name := 'observatory')
+  INTO population;
+
+  RETURN population;
+END;
+$$
+LANGUAGE plpgsql VOLATILE

pg/test/0.0.1/expected/01_install_test.out

@@ -0,0 +1,6 @@
+-- Install dependencies
+CREATE EXTENSION plpythonu;
+CREATE EXTENSION postgis;
+CREATE EXTENSION cartodb;
+-- Install the extension
+CREATE EXTENSION crankshaft;

pg/test/0.0.1/expected/02_moran_test.out

@@ -0,0 +1,260 @@
+\i test/fixtures/ppoints.sql
+-- test table (spanish province centroids with some invented values)
+CREATE TABLE ppoints (cartodb_id integer, the_geom geometry, the_geom_webmercator geometry, code text, region_code text, value float);
+INSERT INTO ppoints VALUES
+( 1,'0101000020E6100000A8306DC0CBC305C051D14B6CE56A4540'::geometry,ST_Transform('0101000020E6100000A8306DC0CBC305C051D14B6CE56A4540'::geometry, 3857),'01','16',0.5),
+( 4,'0101000020E6100000E220A4362DC202C0FD8AFA5119994240'::geometry,ST_Transform('0101000020E6100000E220A4362DC202C0FD8AFA5119994240'::geometry, 3857),'04','01',0.1),
+( 5,'0101000020E610000004377E573AC813C0CB5871BB17494440'::geometry,ST_Transform('0101000020E610000004377E573AC813C0CB5871BB17494440'::geometry, 3857),'05','07',0.3),
+( 2,'0101000020E610000000F49BE19BAFFFBF639958FDA6694340'::geometry,ST_Transform('0101000020E610000000F49BE19BAFFFBF639958FDA6694340'::geometry, 3857),'02','08',0.7),
+( 3,'0101000020E61000005D0B7E63C832E2BFDB63EB00443D4340'::geometry,ST_Transform('0101000020E61000005D0B7E63C832E2BFDB63EB00443D4340'::geometry, 3857),'03','10',0.2),
+( 6,'0101000020E61000006F3742B7FB9018C0DD967DC4D95A4340'::geometry,ST_Transform('0101000020E61000006F3742B7FB9018C0DD967DC4D95A4340'::geometry, 3857),'06','11',0.05),
+( 7,'0101000020E6100000E4BB36995F4C0740EAC0E5CA9FC94340'::geometry,ST_Transform('0101000020E6100000E4BB36995F4C0740EAC0E5CA9FC94340'::geometry, 3857),'07','04',0.4),
+( 8,'0101000020E61000003D43CC6CAFBEFF3F6B52E66F91DD4440'::geometry,ST_Transform('0101000020E61000003D43CC6CAFBEFF3F6B52E66F91DD4440'::geometry, 3857),'08','09',0.7),
+( 9,'0101000020E61000003CC797BD99AF0CC0495A87FA312F4540'::geometry,ST_Transform('0101000020E61000003CC797BD99AF0CC0495A87FA312F4540'::geometry, 3857),'09','07',0.5),
+(13,'0101000020E61000001CAA00A9F19F0EC05DF9267B7A764340'::geometry,ST_Transform('0101000020E61000001CAA00A9F19F0EC05DF9267B7A764340'::geometry, 3857),'13','08',0.4),
+(16,'0101000020E6100000D8208F3CBC9001C065638DC1B1F24340'::geometry,ST_Transform('0101000020E6100000D8208F3CBC9001C065638DC1B1F24340'::geometry, 3857),'16','08',0.4),
+(17,'0101000020E6100000E9E6A94A71630540AD7A0CB062104540'::geometry,ST_Transform('0101000020E6100000E9E6A94A71630540AD7A0CB062104540'::geometry, 3857),'17','09',0.6),
+(18,'0101000020E6100000719792D59E240AC098AC548E00A84240'::geometry,ST_Transform('0101000020E6100000719792D59E240AC098AC548E00A84240'::geometry, 3857),'18','01',0.3),
+(19,'0101000020E6100000972C878B50FD04C0123C881D1F684440'::geometry,ST_Transform('0101000020E6100000972C878B50FD04C0123C881D1F684440'::geometry, 3857),'19','08',0.7),
+(21,'0101000020E6100000F7893E9934511BC0EAA4BF03E1C94240'::geometry,ST_Transform('0101000020E6100000F7893E9934511BC0EAA4BF03E1C94240'::geometry, 3857),'21','01',0.1),
+(22,'0101000020E6100000572C2123B2A8B2BF7ED7FABAFD194540'::geometry,ST_Transform('0101000020E6100000572C2123B2A8B2BF7ED7FABAFD194540'::geometry, 3857),'22','02',0.4),
+(25,'0101000020E6100000461B67D688C4F03FD990EEC3A0054540'::geometry,ST_Transform('0101000020E6100000461B67D688C4F03FD990EEC3A0054540'::geometry, 3857),'25','09',0.4),
+(26,'0101000020E6100000A139FB06E82204C0539D84F62E234540'::geometry,ST_Transform('0101000020E6100000A139FB06E82204C0539D84F62E234540'::geometry, 3857),'26','17',0.6),
+(27,'0101000020E6100000A92E54E618C91DC00D3A947B81814540'::geometry,ST_Transform('0101000020E6100000A92E54E618C91DC00D3A947B81814540'::geometry, 3857),'27','12',0.3),
+(28,'0101000020E6100000971DC8B682BC0DC016D0E8055F3F4440'::geometry,ST_Transform('0101000020E6100000971DC8B682BC0DC016D0E8055F3F4440'::geometry, 3857),'28','13',0.8),
+(30,'0101000020E6100000A2DC1964A8C5F7BF19299C994D004340'::geometry,ST_Transform('0101000020E6100000A2DC1964A8C5F7BF19299C994D004340'::geometry, 3857),'30','14',0.1),
+(31,'0101000020E6100000DCA1FCC87B56FABF9B88E9D866554540'::geometry,ST_Transform('0101000020E6100000DCA1FCC87B56FABF9B88E9D866554540'::geometry, 3857),'31','15',0.9),
+(32,'0101000020E6100000E1517AFCD15E1EC0A18D8D4825194540'::geometry,ST_Transform('0101000020E6100000E1517AFCD15E1EC0A18D8D4825194540'::geometry, 3857),'32','12',0.3),
+(33,'0101000020E6100000A7FF33825AF917C0FABE7DFB6BA54540'::geometry,ST_Transform('0101000020E6100000A7FF33825AF917C0FABE7DFB6BA54540'::geometry, 3857),'33','03',0.4),
+(34,'0101000020E6100000FB4E4EBEB72412C0898E7240982F4540'::geometry,ST_Transform('0101000020E6100000FB4E4EBEB72412C0898E7240982F4540'::geometry, 3857),'34','07',0.3),
+(35,'0101000020E6100000224682B01B1A2DC011091656CC5C3C40'::geometry,ST_Transform('0101000020E6100000224682B01B1A2DC011091656CC5C3C40'::geometry, 3857),'35','05',0.3),
+(36,'0101000020E6100000F7C9447110EC20C04C5D4823C7374540'::geometry,ST_Transform('0101000020E6100000F7C9447110EC20C04C5D4823C7374540'::geometry, 3857),'36','12',0.2),
+(37,'0101000020E610000053D6A26DFB4218C09D58FAE209674440'::geometry,ST_Transform('0101000020E610000053D6A26DFB4218C09D58FAE209674440'::geometry, 3857),'37','07',0.5),
+(38,'0101000020E6100000B1D1B5FC910431C03C0C89BA03503C40'::geometry,ST_Transform('0101000020E6100000B1D1B5FC910431C03C0C89BA03503C40'::geometry, 3857),'38','05',0.4),
+(39,'0101000020E610000086E6FEE1BD1E10C00417096748994540'::geometry,ST_Transform('0101000020E610000086E6FEE1BD1E10C00417096748994540'::geometry, 3857),'39','06',0.6),
+(40,'0101000020E6100000FB51C33F733710C038D01729E4954440'::geometry,ST_Transform('0101000020E6100000FB51C33F733710C038D01729E4954440'::geometry, 3857),'40','07',0.5),
+(41,'0101000020E6100000912D6FDA28BB16C031321F08C4B74240'::geometry,ST_Transform('0101000020E6100000912D6FDA28BB16C031321F08C4B74240'::geometry, 3857),'41','01',0.4),
+(42,'0101000020E6100000554432EABEB504C069ECD78775CF4440'::geometry,ST_Transform('0101000020E6100000554432EABEB504C069ECD78775CF4440'::geometry, 3857),'42','07',0.2),
+(43,'0101000020E6100000157F117C1A2EEA3F027CD1F2368B4440'::geometry,ST_Transform('0101000020E6100000157F117C1A2EEA3F027CD1F2368B4440'::geometry, 3857),'43','09',0.3),
+(44,'0101000020E610000051AA5B1BD718EABFEE67613BA4544440'::geometry,ST_Transform('0101000020E610000051AA5B1BD718EABFEE67613BA4544440'::geometry, 3857),'44','02',0.2),
+(45,'0101000020E610000022C5C01BB69710C08563BC1499E54340'::geometry,ST_Transform('0101000020E610000022C5C01BB69710C08563BC1499E54340'::geometry, 3857),'45','08',0.3),
+(46,'0101000020E6100000D5FCF78A11A0E9BFDEA46F8E64AF4340'::geometry,ST_Transform('0101000020E6100000D5FCF78A11A0E9BFDEA46F8E64AF4340'::geometry, 3857),'46','10',0.2),
+(47,'0101000020E61000003AE63525866313C02100050B2BD14440'::geometry,ST_Transform('0101000020E61000003AE63525866313C02100050B2BD14440'::geometry, 3857),'47','07',0.3),
+(48,'0101000020E610000030F187FD1FD206C0C767E1496C9E4540'::geometry,ST_Transform('0101000020E610000030F187FD1FD206C0C767E1496C9E4540'::geometry, 3857),'48','16',0.5),
+(49,'0101000020E61000009C22867B12EC17C006C5F40C14DD4440'::geometry,ST_Transform('0101000020E61000009C22867B12EC17C006C5F40C14DD4440'::geometry, 3857),'49','07',0.2),
+(50,'0101000020E6100000F7D5EFC62D08F1BF69D1231D68CF4440'::geometry,ST_Transform('0101000020E6100000F7D5EFC62D08F1BF69D1231D68CF4440'::geometry, 3857),'50','02',0.6),
+(51,'0101000020E61000005B0E1F8DAA5F15C0530BFE285BF24140'::geometry,ST_Transform('0101000020E61000005B0E1F8DAA5F15C0530BFE285BF24140'::geometry, 3857),'51','18',0.01),
+(10,'0101000020E61000000FD65D82AEA418C06192D1351FDB4340'::geometry,ST_Transform('0101000020E61000000FD65D82AEA418C06192D1351FDB4340'::geometry, 3857),'10','11',0.04),
+(11,'0101000020E6100000B305531DAB0A17C0DEAFCD4EE5464240'::geometry,ST_Transform('0101000020E6100000B305531DAB0A17C0DEAFCD4EE5464240'::geometry, 3857),'11','01',0.08),
+(12,'0101000020E610000059721A7297C9C2BF9EBE383BE51E4440'::geometry,ST_Transform('0101000020E610000059721A7297C9C2BF9EBE383BE51E4440'::geometry, 3857),'12','10',0.2),
+(14,'0101000020E610000000C86313AF3C13C0E530879C10FF4240'::geometry,ST_Transform('0101000020E610000000C86313AF3C13C0E530879C10FF4240'::geometry, 3857),'14','01',0.2),
+(15,'0101000020E61000002A475497B6ED20C06643D4131A904540'::geometry,ST_Transform('0101000020E61000002A475497B6ED20C06643D4131A904540'::geometry, 3857),'15','12',0.3),
+(20,'0101000020E6100000F975566FAD8D01C0E840C33F67924540'::geometry,ST_Transform('0101000020E6100000F975566FAD8D01C0E840C33F67924540'::geometry, 3857),'20','16',0.8),
+(23,'0101000020E610000025FA13E595880BC022BB07131D024340'::geometry,ST_Transform('0101000020E610000025FA13E595880BC022BB07131D024340'::geometry, 3857),'23','01',0.1),
+(24,'0101000020E61000009C5F91C5095C17C0C78784B15A4F4540'::geometry,ST_Transform('0101000020E61000009C5F91C5095C17C0C78784B15A4F4540'::geometry, 3857),'24','07',0.3),
+(29,'0101000020E6100000C34D4A5B48E712C092E680892C684240'::geometry,ST_Transform('0101000020E6100000C34D4A5B48E712C092E680892C684240'::geometry, 3857),'29','01',0.3),
+(52,'0101000020E6100000406A545EB29A07C04E5F0BDA39A54140'::geometry,ST_Transform('0101000020E6100000406A545EB29A07C04E5F0BDA39A54140'::geometry, 3857),'52','19',0.01)
+\i test/fixtures/ppoints2.sql
+-- test table (spanish province centroids with some invented values)
+CREATE TABLE ppoints2 (cartodb_id integer, the_geom geometry, code text, region_code text, numerator float, denominator float);
+INSERT INTO ppoints2 VALUES
+( 1,'0101000020E6100000A8306DC0CBC305C051D14B6CE56A4540'::geometry,'01','16',0.5, 1.0),
+( 4,'0101000020E6100000E220A4362DC202C0FD8AFA5119994240'::geometry,'04','01',0.1, 1.0),
+( 5,'0101000020E610000004377E573AC813C0CB5871BB17494440'::geometry,'05','07',0.3, 1.0),
+( 2,'0101000020E610000000F49BE19BAFFFBF639958FDA6694340'::geometry,'02','08',0.7, 1.0),
+( 3,'0101000020E61000005D0B7E63C832E2BFDB63EB00443D4340'::geometry,'03','10',0.2, 1.0),
+( 6,'0101000020E61000006F3742B7FB9018C0DD967DC4D95A4340'::geometry,'06','11',0.05, 1.0),
+( 7,'0101000020E6100000E4BB36995F4C0740EAC0E5CA9FC94340'::geometry,'07','04',0.4, 1.0),
+( 8,'0101000020E61000003D43CC6CAFBEFF3F6B52E66F91DD4440'::geometry,'08','09',0.7, 1.0),
+( 9,'0101000020E61000003CC797BD99AF0CC0495A87FA312F4540'::geometry,'09','07',0.5, 1.0),
+(13,'0101000020E61000001CAA00A9F19F0EC05DF9267B7A764340'::geometry,'13','08',0.4, 1.0),
+(16,'0101000020E6100000D8208F3CBC9001C065638DC1B1F24340'::geometry,'16','08',0.4, 1.0),
+(17,'0101000020E6100000E9E6A94A71630540AD7A0CB062104540'::geometry,'17','09',0.6, 1.0),
+(18,'0101000020E6100000719792D59E240AC098AC548E00A84240'::geometry,'18','01',0.3, 1.0),
+(19,'0101000020E6100000972C878B50FD04C0123C881D1F684440'::geometry,'19','08',0.7, 1.0),
+(21,'0101000020E6100000F7893E9934511BC0EAA4BF03E1C94240'::geometry,'21','01',0.1, 1.0),
+(22,'0101000020E6100000572C2123B2A8B2BF7ED7FABAFD194540'::geometry,'22','02',0.4, 1.0),
+(25,'0101000020E6100000461B67D688C4F03FD990EEC3A0054540'::geometry,'25','09',0.4, 1.0),
+(26,'0101000020E6100000A139FB06E82204C0539D84F62E234540'::geometry,'26','17',0.6, 1.0),
+(27,'0101000020E6100000A92E54E618C91DC00D3A947B81814540'::geometry,'27','12',0.3, 1.0),
+(28,'0101000020E6100000971DC8B682BC0DC016D0E8055F3F4440'::geometry,'28','13',0.8, 1.0),
+(30,'0101000020E6100000A2DC1964A8C5F7BF19299C994D004340'::geometry,'30','14',0.1, 1.0),
+(31,'0101000020E6100000DCA1FCC87B56FABF9B88E9D866554540'::geometry,'31','15',0.9, 1.0),
+(32,'0101000020E6100000E1517AFCD15E1EC0A18D8D4825194540'::geometry,'32','12',0.3, 1.0),
+(33,'0101000020E6100000A7FF33825AF917C0FABE7DFB6BA54540'::geometry,'33','03',0.4, 1.0),
+(34,'0101000020E6100000FB4E4EBEB72412C0898E7240982F4540'::geometry,'34','07',0.3, 1.0),
+(35,'0101000020E6100000224682B01B1A2DC011091656CC5C3C40'::geometry,'35','05',0.3, 1.0),
+(36,'0101000020E6100000F7C9447110EC20C04C5D4823C7374540'::geometry,'36','12',0.2, 1.0),
+(37,'0101000020E610000053D6A26DFB4218C09D58FAE209674440'::geometry,'37','07',0.5, 1.0),
+(38,'0101000020E6100000B1D1B5FC910431C03C0C89BA03503C40'::geometry,'38','05',0.4, 1.0),
+(39,'0101000020E610000086E6FEE1BD1E10C00417096748994540'::geometry,'39','06',0.6, 1.0),
+(40,'0101000020E6100000FB51C33F733710C038D01729E4954440'::geometry,'40','07',0.5, 1.0),
+(41,'0101000020E6100000912D6FDA28BB16C031321F08C4B74240'::geometry,'41','01',0.4, 1.0),
+(42,'0101000020E6100000554432EABEB504C069ECD78775CF4440'::geometry,'42','07',0.2, 1.0),
+(43,'0101000020E6100000157F117C1A2EEA3F027CD1F2368B4440'::geometry,'43','09',0.3, 1.0),
+(44,'0101000020E610000051AA5B1BD718EABFEE67613BA4544440'::geometry,'44','02',0.2, 1.0),
+(45,'0101000020E610000022C5C01BB69710C08563BC1499E54340'::geometry,'45','08',0.3, 1.0),
+(46,'0101000020E6100000D5FCF78A11A0E9BFDEA46F8E64AF4340'::geometry,'46','10',0.2, 1.0),
+(47,'0101000020E61000003AE63525866313C02100050B2BD14440'::geometry,'47','07',0.3, 1.0),
+(48,'0101000020E610000030F187FD1FD206C0C767E1496C9E4540'::geometry,'48','16',0.5, 1.0),
+(49,'0101000020E61000009C22867B12EC17C006C5F40C14DD4440'::geometry,'49','07',0.2, 1.0),
+(50,'0101000020E6100000F7D5EFC62D08F1BF69D1231D68CF4440'::geometry,'50','02',0.6, 1.0),
+(51,'0101000020E61000005B0E1F8DAA5F15C0530BFE285BF24140'::geometry,'51','18',0.01, 1.0),
+(10,'0101000020E61000000FD65D82AEA418C06192D1351FDB4340'::geometry,'10','11',0.04, 1.0),
+(11,'0101000020E6100000B305531DAB0A17C0DEAFCD4EE5464240'::geometry,'11','01',0.08, 1.0),
+(12,'0101000020E610000059721A7297C9C2BF9EBE383BE51E4440'::geometry,'12','10',0.2, 1.0),
+(14,'0101000020E610000000C86313AF3C13C0E530879C10FF4240'::geometry,'14','01',0.2, 1.0),
+(15,'0101000020E61000002A475497B6ED20C06643D4131A904540'::geometry,'15','12',0.3, 1.0),
+(20,'0101000020E6100000F975566FAD8D01C0E840C33F67924540'::geometry,'20','16',0.8, 1.0),
+(23,'0101000020E610000025FA13E595880BC022BB07131D024340'::geometry,'23','01',0.1, 1.0),
+(24,'0101000020E61000009C5F91C5095C17C0C78784B15A4F4540'::geometry,'24','07',0.3, 1.0),
+(29,'0101000020E6100000C34D4A5B48E712C092E680892C684240'::geometry,'29','01',0.3, 1.0),
+(52,'0101000020E6100000406A545EB29A07C04E5F0BDA39A54140'::geometry,'52','19',0.0, 1.01)
+-- Moral functions perform some nondeterministic computations
+-- (to estimate the significance); we will set the seeds for the RNGs
+-- that affect those results to have repeateble results
+SELECT cdb_crankshaft._cdb_random_seeds(1234);
+ _cdb_random_seeds 
+-------------------
+ 
+(1 row)
+
+SELECT ppoints.code, m.quads
+  FROM ppoints
+  JOIN cdb_crankshaft.cdb_moran_local('ppoints', 'value') m
+    ON ppoints.cartodb_id = m.ids
+  ORDER BY ppoints.code;
+NOTICE:  ** Constructing query
+CONTEXT:  PL/Python function "cdb_moran_local"
+NOTICE:  ** Query returned with 52 rows
+CONTEXT:  PL/Python function "cdb_moran_local"
+NOTICE:  ** Finished calculations
+CONTEXT:  PL/Python function "cdb_moran_local"
+ code |      quads      
+------+-----------------
+ 01   | HH
+ 02   | HL
+ 03   | Not significant
+ 04   | Not significant
+ 05   | Not significant
+ 06   | Not significant
+ 07   | Not significant
+ 08   | Not significant
+ 09   | Not significant
+ 10   | Not significant
+ 11   | LL
+ 12   | Not significant
+ 13   | Not significant
+ 14   | Not significant
+ 15   | Not significant
+ 16   | HH
+ 17   | Not significant
+ 18   | Not significant
+ 19   | Not significant
+ 20   | HH
+ 21   | LL
+ 22   | Not significant
+ 23   | Not significant
+ 24   | Not significant
+ 25   | HH
+ 26   | HH
+ 27   | Not significant
+ 28   | Not significant
+ 29   | LL
+ 30   | Not significant
+ 31   | HH
+ 32   | Not significant
+ 33   | Not significant
+ 34   | Not significant
+ 35   | LL
+ 36   | Not significant
+ 37   | Not significant
+ 38   | HL
+ 39   | Not significant
+ 40   | Not significant
+ 41   | HL
+ 42   | LH
+ 43   | Not significant
+ 44   | Not significant
+ 45   | LH
+ 46   | Not significant
+ 47   | Not significant
+ 48   | HH
+ 49   | Not significant
+ 50   | Not significant
+ 51   | LL
+ 52   | LL
+(52 rows)
+
+SELECT cdb_crankshaft._cdb_random_seeds(1234);
+ _cdb_random_seeds 
+-------------------
+ 
+(1 row)
+
+SELECT ppoints2.code, m.quads
+  FROM ppoints2
+  JOIN cdb_crankshaft.cdb_moran_local_rate('ppoints2', 'numerator', 'denominator') m
+    ON ppoints2.cartodb_id = m.ids
+  ORDER BY ppoints2.code;
+NOTICE:  ** Constructing query
+CONTEXT:  PL/Python function "cdb_moran_local_rate"
+NOTICE:  ** Query returned with 51 rows
+CONTEXT:  PL/Python function "cdb_moran_local_rate"
+NOTICE:  ** Finished calculations
+CONTEXT:  PL/Python function "cdb_moran_local_rate"
+ code |      quads      
+------+-----------------
+ 01   | LL
+ 02   | Not significant
+ 03   | Not significant
+ 04   | Not significant
+ 05   | Not significant
+ 06   | Not significant
+ 07   | Not significant
+ 08   | Not significant
+ 09   | LL
+ 10   | Not significant
+ 11   | HH
+ 12   | Not significant
+ 13   | Not significant
+ 14   | Not significant
+ 15   | Not significant
+ 16   | Not significant
+ 17   | LL
+ 18   | Not significant
+ 19   | Not significant
+ 20   | LL
+ 21   | Not significant
+ 22   | Not significant
+ 23   | Not significant
+ 24   | Not significant
+ 25   | LL
+ 26   | LL
+ 27   | Not significant
+ 28   | Not significant
+ 29   | LH
+ 30   | Not significant
+ 31   | LL
+ 32   | Not significant
+ 33   | Not significant
+ 34   | Not significant
+ 35   | LH
+ 36   | Not significant
+ 37   | Not significant
+ 38   | LH
+ 39   | Not significant
+ 40   | Not significant
+ 41   | LH
+ 42   | HL
+ 43   | Not significant
+ 44   | Not significant
+ 45   | LL
+ 46   | Not significant
+ 47   | Not significant
+ 48   | LL
+ 49   | Not significant
+ 50   | Not significant
+ 51   | Not significant
+(51 rows)
+

pg/test/0.0.1/expected/03_overlap_sum_test.out

@@ -0,0 +1,23 @@
+\i test/fixtures/polyg_values.sql
+CREATE TABLE values (cartodb_id integer, value float, the_geom geometry);
+INSERT INTO values(cartodb_id, value, the_geom) VALUES
+(1,10,'0106000020E61000000100000001030000000100000005000000E5AF3500C03608C08068629111374440C7BC0A00C00F02C0AC0551523B414440C7BC0A00C0A700C0CAF23B6E74FB4340A7267FFFFF5206C0FBB7E41B7EE74340E5AF3500C03608C08068629111374440'::geometry),
+(2,20,'0106000020E610000001000000010300000001000000050000002439EC00804AF7BF07D6CCB5C3064440C7BC0A00C0A700C0CAF23B6E74FB4340C7BC0A00C00F02C0AC0551523B414440E20CD5FFFF30FABFBE4F76AFEA4B44402439EC00804AF7BF07D6CCB5C3064440'::geometry)
+SELECT round(cdb_crankshaft.cdb_overlap_sum(
+  '0106000020E61000000100000001030000000100000004000000FFFFFFFFFF3604C09A0B9ECEC42E444000000000C060FBBF30C7FD70E01D44400000000040AD02C06481F1C8CD034440FFFFFFFFFF3604C09A0B9ECEC42E4440'::geometry,
+  'values', 'value'
+), 2);
+ round 
+-------
+  4.42
+(1 row)
+
+SELECT round(cdb_crankshaft.cdb_overlap_sum(
+  '0106000020E61000000100000001030000000100000004000000FFFFFFFFFF3604C09A0B9ECEC42E444000000000C060FBBF30C7FD70E01D44400000000040AD02C06481F1C8CD034440FFFFFFFFFF3604C09A0B9ECEC42E4440'::geometry,
+  'values', 'value', schema_name := 'public'
+), 2);
+ round 
+-------
+  4.42
+(1 row)
+

pg/test/0.0.1/results/01_install_test.out

@@ -0,0 +1,6 @@
+-- Install dependencies
+CREATE EXTENSION plpythonu;
+CREATE EXTENSION postgis;
+CREATE EXTENSION cartodb;
+-- Install the extension
+CREATE EXTENSION crankshaft;

pg/test/0.0.1/sql/01_install_test.sql

@@ -0,0 +1,7 @@
+-- Install dependencies
+CREATE EXTENSION plpythonu;
+CREATE EXTENSION postgis;
+CREATE EXTENSION cartodb;
+
+-- Install the extension
+CREATE EXTENSION crankshaft;

pg/test/0.0.1/sql/02_moran_test.sql

@@ -0,0 +1,21 @@
+\i test/fixtures/ppoints.sql
+\i test/fixtures/ppoints2.sql
+
+-- Moral functions perform some nondeterministic computations
+-- (to estimate the significance); we will set the seeds for the RNGs
+-- that affect those results to have repeateble results
+SELECT cdb_crankshaft._cdb_random_seeds(1234);
+
+SELECT ppoints.code, m.quads
+  FROM ppoints
+  JOIN cdb_crankshaft.cdb_moran_local('ppoints', 'value') m
+    ON ppoints.cartodb_id = m.ids
+  ORDER BY ppoints.code;
+
+SELECT cdb_crankshaft._cdb_random_seeds(1234);
+
+SELECT ppoints2.code, m.quads
+  FROM ppoints2
+  JOIN cdb_crankshaft.cdb_moran_local_rate('ppoints2', 'numerator', 'denominator') m
+    ON ppoints2.cartodb_id = m.ids
+  ORDER BY ppoints2.code;

pg/test/fixtures/polyg_values.sql

@@ -1,5 +1,3 @@
-SET client_min_messages TO WARNING;
-\set ECHO none
 CREATE TABLE values (cartodb_id integer, value float, the_geom geometry);
 INSERT INTO values(cartodb_id, value, the_geom) VALUES
 (1,10,'0106000020E61000000100000001030000000100000005000000E5AF3500C03608C08068629111374440C7BC0A00C00F02C0AC0551523B414440C7BC0A00C0A700C0CAF23B6E74FB4340A7267FFFFF5206C0FBB7E41B7EE74340E5AF3500C03608C08068629111374440'::geometry),

pg/test/fixtures/ppoints.sql

@@ -1,5 +1,3 @@
-SET client_min_messages TO WARNING;
-\set ECHO none
 -- test table (spanish province centroids with some invented values)
 CREATE TABLE ppoints (cartodb_id integer, the_geom geometry, the_geom_webmercator geometry, code text, region_code text, value float);
 INSERT INTO ppoints VALUES

pg/test/fixtures/ppoints2.sql

@@ -1,5 +1,3 @@
-SET client_min_messages TO WARNING;
-\set ECHO none
 -- test table (spanish province centroids with some invented values)
 CREATE TABLE ppoints2 (cartodb_id integer, the_geom geometry, code text, region_code text, numerator float, denominator float);
 INSERT INTO ppoints2 VALUES

python/.gitignore

@@ -0,0 +1 @@
+*.pyc

python/Makefile

@@ -0,0 +1,11 @@
+# Install the package (needs root privileges)
+install:
+	pip install ./crankshaft --upgrade
+
+# Test from source code
+test:
+	(cd crankshaft && nosetests test/)
+
+# Test currently installed package
+testinstalled:
+	nosetests crankshaft/test/

python/README.md

@@ -0,0 +1,9 @@
+# Crankshaft Python Package
+
+...
+### Run the tests
+
+```bash
+cd crankshaft
+nosetests test/
+```

release/crankshaft--0.0.1--0.0.2.sql

@@ -1,74 +0,0 @@
-CREATE OR REPLACE FUNCTION cdb_crankshaft.cdb_crankshaft_version()
-RETURNS text AS $$
-  SELECT '0.0.2'::text;
-$$ language 'sql' STABLE STRICT;
-
-CREATE OR REPLACE FUNCTION cdb_crankshaft._cdb_crankshaft_internal_version()
-RETURNS text AS $$
-  SELECT installed_version FROM pg_available_extensions where name='crankshaft' and pg_available_extensions IS NOT NULL;
-$$ language 'sql' STABLE STRICT;
-CREATE OR REPLACE FUNCTION cdb_crankshaft._cdb_crankshaft_virtualenvs_path()
-RETURNS text
-AS $$
-  BEGIN
-    RETURN '/home/ubuntu/crankshaft/envs';
-  END;
-$$ language plpgsql IMMUTABLE STRICT;
-
-CREATE OR REPLACE FUNCTION cdb_crankshaft._cdb_crankshaft_activate_py()
-RETURNS VOID
-AS $$
-    import os
-    # plpy.notice('%',str(os.environ))
-    # activate virtualenv
-    crankshaft_version = plpy.execute('SELECT cdb_crankshaft._cdb_crankshaft_internal_version()')[0]['_cdb_crankshaft_internal_version']
-    base_path = plpy.execute('SELECT cdb_crankshaft._cdb_crankshaft_virtualenvs_path()')[0]['_cdb_crankshaft_virtualenvs_path']
-    default_venv_path = os.path.join(base_path, crankshaft_version)
-    venv_path =  os.environ.get('CRANKSHAFT_VENV', default_venv_path)
-    activate_path = venv_path + '/bin/activate_this.py'
-    exec(open(activate_path).read(), dict(__file__=activate_path))
-$$ LANGUAGE plpythonu;
-
-CREATE OR REPLACE FUNCTION
-cdb_crankshaft._cdb_random_seeds (seed_value INTEGER) RETURNS VOID
-AS $$
-  plpy.execute('SELECT cdb_crankshaft._cdb_crankshaft_activate_py()')
-  from crankshaft import random_seeds
-  random_seeds.set_random_seeds(seed_value)
-$$ LANGUAGE plpythonu;
--- Moran's I
-CREATE OR REPLACE FUNCTION
-cdb_crankshaft.cdb_moran_local (
-      t TEXT,
-  	  attr TEXT,
-  	  significance float DEFAULT 0.05,
-  	  num_ngbrs INT DEFAULT 5,
-  	  permutations INT DEFAULT 99,
-  	  geom_column TEXT DEFAULT 'the_geom',
-  	  id_col TEXT DEFAULT 'cartodb_id',
-      w_type TEXT DEFAULT 'knn')
-RETURNS TABLE (moran FLOAT, quads TEXT, significance FLOAT, ids INT)
-AS $$
-  plpy.execute('SELECT cdb_crankshaft._cdb_crankshaft_activate_py()')
-  from crankshaft.clustering import moran_local
-  # TODO: use named parameters or a dictionary
-  return moran_local(t, attr, significance, num_ngbrs, permutations, geom_column, id_col, w_type)
-$$ LANGUAGE plpythonu;
-
-CREATE OR REPLACE FUNCTION
-cdb_crankshaft.cdb_moran_local_rate(t TEXT,
-		 numerator TEXT,
-		 denominator TEXT,
-		 significance FLOAT DEFAULT 0.05,
-		 num_ngbrs INT DEFAULT 5,
-		 permutations INT DEFAULT 99,
-		 geom_column TEXT DEFAULT 'the_geom',
-		 id_col TEXT DEFAULT 'cartodb_id',
-		 w_type TEXT DEFAULT 'knn')
-RETURNS TABLE(moran FLOAT, quads TEXT, significance FLOAT, ids INT, y numeric)
-AS $$
-  plpy.execute('SELECT cdb_crankshaft._cdb_crankshaft_activate_py()')
-  from crankshaft.clustering import moran_local_rate
-  # TODO: use named parameters or a dictionary
-  return moran_local_rate(t, numerator, denominator, significance, num_ngbrs, permutations, geom_column, id_col, w_type)
-$$ LANGUAGE plpythonu;

release/crankshaft--0.0.2--0.0.3.sql

@@ -1,413 +0,0 @@
---DO NOT MODIFY THIS FILE, IT IS GENERATED AUTOMATICALLY FROM SOURCES
--- Complain if script is sourced in psql, rather than via CREATE EXTENSION
-\echo Use "CREATE EXTENSION crankshaft" to load this file. \quit
-
--- [MANUALLY] DROP FUNCTIONS REMOVED SINCE 0.0.2 version
-
-DROP FUNCTION IF EXISTS cdb_moran_local(TEXT, TEXT, float, INT, INT, TEXT, TEXT, TEXT);
-DROP FUNCTION IF EXISTS cdb_moran_local_rate(TEXT, TEXT, TEXT, FLOAT, INT, INT, TEXT, TEXT, TEXT);
-DROP FUNCTION IF EXISTS _cdb_crankshaft_virtualenvs_path();
-DROP FUNCTION IF EXISTS _cdb_crankshaft_activate_py();
-
--- [END MANUALLY] DROP FUNCTIONS REMOVED SINCE 0.0.2 version
-
--- Version number of the extension release
-CREATE OR REPLACE FUNCTION cdb_crankshaft_version()
-    RETURNS text AS $$
-  SELECT '0.0.3'::text;
-$$ language 'sql' STABLE STRICT;
-
--- Internal identifier of the installed extension instence
--- e.g. 'dev' for current development version
-CREATE OR REPLACE FUNCTION _cdb_crankshaft_internal_version()
-    RETURNS text AS $$
-  SELECT installed_version FROM pg_available_extensions where name='crankshaft' and pg_available_extensions IS NOT NULL;
-$$ language 'sql' STABLE STRICT;
--- Internal function.
--- Set the seeds of the RNGs (Random Number Generators)
--- used internally.
-CREATE OR REPLACE FUNCTION
-    _cdb_random_seeds (seed_value INTEGER) RETURNS VOID
-AS $$
-  from crankshaft import random_seeds
-  random_seeds.set_random_seeds(seed_value)
-$$ LANGUAGE plpythonu;
--- Moran's I Global Measure (public-facing)
-CREATE OR REPLACE FUNCTION
-    CDB_AreasOfInterestGlobal(
-    subquery TEXT,
-    column_name TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS TABLE (moran NUMERIC, significance NUMERIC)
-AS $$
-  from crankshaft.clustering import moran_local
-  # TODO: use named parameters or a dictionary
-  return moran(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
--- Moran's I Local (internal function)
-CREATE OR REPLACE FUNCTION
-    _CDB_AreasOfInterestLocal(
-    subquery TEXT,
-    column_name TEXT,
-    w_type TEXT,
-    num_ngbrs INT,
-    permutations INT,
-    geom_col TEXT,
-    id_col TEXT)
-    RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-  from crankshaft.clustering import moran_local
-  # TODO: use named parameters or a dictionary
-  return moran_local(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
--- Moran's I Local (public-facing function)
-CREATE OR REPLACE FUNCTION
-    CDB_AreasOfInterestLocal(
-    subquery TEXT,
-    column_name TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col);
-
-$$ LANGUAGE SQL;
-
--- Moran's I only for HH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-    CDB_GetSpatialHotspots(
-    subquery TEXT,
-    column_name TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HH', 'HL');
-
-$$ LANGUAGE SQL;
-
--- Moran's I only for LL and LH (public-facing function)
-CREATE OR REPLACE FUNCTION
-    CDB_GetSpatialColdspots(
-    subquery TEXT,
-    attr TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, attr, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('LL', 'LH');
-
-$$ LANGUAGE SQL;
-
--- Moran's I only for LH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-    CDB_GetSpatialOutliers(
-    subquery TEXT,
-    attr TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, attr, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HL', 'LH');
-
-$$ LANGUAGE SQL;
-
--- Moran's I Global Rate (public-facing function)
-CREATE OR REPLACE FUNCTION
-    CDB_AreasOfInterestGlobalRate(
-    subquery TEXT,
-    numerator TEXT,
-    denominator TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS TABLE (moran FLOAT, significance FLOAT)
-AS $$
-  from crankshaft.clustering import moran_local
-  # TODO: use named parameters or a dictionary
-  return moran_rate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
-
--- Moran's I Local Rate (internal function)
-CREATE OR REPLACE FUNCTION
-    _CDB_AreasOfInterestLocalRate(
-    subquery TEXT,
-    numerator TEXT,
-    denominator TEXT,
-    w_type TEXT,
-    num_ngbrs INT,
-    permutations INT,
-    geom_col TEXT,
-    id_col TEXT)
-    RETURNS
-        TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-  from crankshaft.clustering import moran_local_rate
-  # TODO: use named parameters or a dictionary
-  return moran_local_rate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
--- Moran's I Local Rate (public-facing function)
-CREATE OR REPLACE FUNCTION
-    CDB_AreasOfInterestLocalRate(
-    subquery TEXT,
-    numerator TEXT,
-    denominator TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS
-        TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col);
-
-$$ LANGUAGE SQL;
-
--- Moran's I Local Rate only for HH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-    CDB_GetSpatialHotspotsRate(
-    subquery TEXT,
-    numerator TEXT,
-    denominator TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS
-        TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HH', 'HL');
-
-$$ LANGUAGE SQL;
-
--- Moran's I Local Rate only for LL and LH (public-facing function)
-CREATE OR REPLACE FUNCTION
-    CDB_GetSpatialColdspotsRate(
-    subquery TEXT,
-    numerator TEXT,
-    denominator TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS
-        TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('LL', 'LH');
-
-$$ LANGUAGE SQL;
-
--- Moran's I Local Rate only for LH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-    CDB_GetSpatialOutliersRate(
-    subquery TEXT,
-    numerator TEXT,
-    denominator TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS
-        TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HL', 'LH');
-
-$$ LANGUAGE SQL;
-CREATE OR REPLACE FUNCTION  CDB_KMeans(query text, no_clusters integer,no_init integer default 20)
-    RETURNS table (cartodb_id integer, cluster_no integer) as $$
-    
-    from crankshaft.clustering import kmeans
-    return kmeans(query,no_clusters,no_init)
-
-$$ language plpythonu;
-
-
-CREATE OR REPLACE FUNCTION CDB_WeightedMeanS(state Numeric[],the_geom GEOMETRY(Point, 4326), weight NUMERIC)
-    RETURNS Numeric[] AS
-    $$
-DECLARE 
-    newX NUMERIC;
-    newY NUMERIC;
-    newW NUMERIC;
-BEGIN
-    IF weight IS NULL OR the_geom IS NULL THEN 
-        newX = state[1];
-        newY = state[2];
-        newW = state[3];
-    ELSE
-        newX = state[1] + ST_X(the_geom)*weight;
-        newY = state[2] + ST_Y(the_geom)*weight;
-        newW = state[3] + weight;
-    END IF;
-    RETURN Array[newX,newY,newW];
-
-END
-$$ LANGUAGE plpgsql;
-
-CREATE OR REPLACE FUNCTION CDB_WeightedMeanF(state Numeric[])
-    RETURNS GEOMETRY AS
-    $$
-BEGIN
-    IF state[3] = 0 THEN 
-        RETURN ST_SetSRID(ST_MakePoint(state[1],state[2]), 4326);
-    ELSE 
-        RETURN ST_SETSRID(ST_MakePoint(state[1]/state[3], state[2]/state[3]),4326);
-    END IF;
-END
-$$ LANGUAGE plpgsql;
-
-CREATE AGGREGATE CDB_WeightedMean(geometry(Point, 4326), NUMERIC)(
-SFUNC = CDB_WeightedMeanS,
-FINALFUNC = CDB_WeightedMeanF,
-STYPE = Numeric[],
-INITCOND = "{0.0,0.0,0.0}"
-);
--- Function by Stuart Lynn for a simple interpolation of a value
--- from a polygon table over an arbitrary polygon
--- (weighted by the area proportion overlapped)
--- Aereal weighting is a very simple form of aereal interpolation.
---
--- Parameters:
---   * geom a Polygon geometry which defines the area where a value will be
---     estimated as the area-weighted sum of a given table/column
---   * target_table_name table name of the table that provides the values
---   * target_column column name of the column that provides the values
---   * schema_name optional parameter to defina the schema the target table
---     belongs to, which is necessary if its not in the search_path.
---     Note that target_table_name should never include the schema in it.
--- Return value:
---   Aereal-weighted interpolation of the column values over the geometry
-CREATE OR REPLACE
-FUNCTION cdb_overlap_sum(geom geometry, target_table_name text, target_column text, schema_name text DEFAULT NULL)
-    RETURNS numeric AS
-    $$
-    DECLARE
-        result numeric;
-        qualified_name text;
-    BEGIN
-        IF schema_name IS NULL THEN
-            qualified_name := Format('%I', target_table_name);
-        ELSE
-            qualified_name := Format('%I.%s', schema_name, target_table_name);
-        END IF;
-        EXECUTE Format('
-    SELECT sum(%I*ST_Area(St_Intersection($1, a.the_geom))/ST_Area(a.the_geom))
-    FROM %s AS a
-    WHERE $1 && a.the_geom
-  ', target_column, qualified_name)
-        USING geom
-        INTO result;
-        RETURN result;
-    END;
-    $$ LANGUAGE plpgsql;
---
--- Creates N points randomly distributed arround the polygon
---
--- @param g - the geometry to be turned in to points
---
--- @param no_points - the number of points to generate
---
--- @params max_iter_per_point - the function generates points in the polygon's bounding box
--- and discards points which don't lie in the polygon. max_iter_per_point specifies how many
--- misses per point the funciton accepts before giving up.
---
--- Returns: Multipoint with the requested points
-CREATE OR REPLACE FUNCTION cdb_dot_density(geom geometry , no_points Integer, max_iter_per_point Integer DEFAULT 1000)
-    RETURNS GEOMETRY AS $$
-DECLARE
-    extent GEOMETRY;
-    test_point Geometry;
-    width                NUMERIC;
-    height               NUMERIC;
-    x0                   NUMERIC;
-    y0                   NUMERIC;
-    xp                   NUMERIC;
-    yp                   NUMERIC;
-    no_left              INTEGER;
-    remaining_iterations INTEGER;
-    points               GEOMETRY[];
-    bbox_line            GEOMETRY;
-    intersection_line    GEOMETRY;
-BEGIN
-    extent  := ST_Envelope(geom);
-    width   := ST_XMax(extent) - ST_XMIN(extent);
-    height  := ST_YMax(extent) - ST_YMIN(extent);
-    x0 	  := ST_XMin(extent);
-    y0 	  := ST_YMin(extent);
-    no_left := no_points;
-
-    LOOP
-        if(no_left=0) THEN
-            EXIT;
-        END IF;
-        yp = y0 + height*random();
-        bbox_line  = ST_MakeLine(
-            ST_SetSRID(ST_MakePoint(yp, x0),4326),
-            ST_SetSRID(ST_MakePoint(yp, x0+width),4326)
-        );
-        intersection_line = ST_Intersection(bbox_line,geom);
-        test_point = ST_LineInterpolatePoint(st_makeline(st_linemerge(intersection_line)),random());
-        points := points || test_point;
-        no_left = no_left - 1 ;
-    END LOOP;
-    RETURN ST_Collect(points);
-END;
-$$
-LANGUAGE plpgsql VOLATILE;
--- Make sure by default there are no permissions for publicuser
--- NOTE: this happens at extension creation time, as part of an implicit transaction.
--- REVOKE ALL PRIVILEGES ON SCHEMA cdb_crankshaft FROM PUBLIC, publicuser CASCADE;
-
--- Grant permissions on the schema to publicuser (but just the schema)
-GRANT USAGE ON SCHEMA cdb_crankshaft TO publicuser;
-
--- Revoke execute permissions on all functions in the schema by default
--- REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_crankshaft FROM PUBLIC, publicuser;

release/crankshaft--0.0.2.sql

@@ -1,186 +0,0 @@
---DO NOT MODIFY THIS FILE, IT IS GENERATED AUTOMATICALLY FROM SOURCES
--- Complain if script is sourced in psql, rather than via CREATE EXTENSION
-\echo Use "CREATE EXTENSION crankshaft" to load this file. \quit
--- Version number of the extension release
-CREATE OR REPLACE FUNCTION cdb_crankshaft_version()
-RETURNS text AS $$
-  SELECT '0.0.2'::text;
-$$ language 'sql' STABLE STRICT;
-
--- Internal identifier of the installed extension instence
--- e.g. 'dev' for current development version
-CREATE OR REPLACE FUNCTION _cdb_crankshaft_internal_version()
-RETURNS text AS $$
-  SELECT installed_version FROM pg_available_extensions where name='crankshaft' and pg_available_extensions IS NOT NULL;
-$$ language 'sql' STABLE STRICT;
-CREATE OR REPLACE FUNCTION _cdb_crankshaft_virtualenvs_path()
-RETURNS text
-AS $$
-  BEGIN
-    -- RETURN '/opt/virtualenvs/crankshaft';
-    RETURN '/home/ubuntu/crankshaft/envs';
-  END;
-$$ language plpgsql IMMUTABLE STRICT;
-
--- Use the crankshaft python module
-CREATE OR REPLACE FUNCTION _cdb_crankshaft_activate_py()
-RETURNS VOID
-AS $$
-    import os
-    # plpy.notice('%',str(os.environ))
-    # activate virtualenv
-    crankshaft_version = plpy.execute('SELECT cdb_crankshaft._cdb_crankshaft_internal_version()')[0]['_cdb_crankshaft_internal_version']
-    base_path = plpy.execute('SELECT cdb_crankshaft._cdb_crankshaft_virtualenvs_path()')[0]['_cdb_crankshaft_virtualenvs_path']
-    default_venv_path = os.path.join(base_path, crankshaft_version)
-    venv_path =  os.environ.get('CRANKSHAFT_VENV', default_venv_path)
-    activate_path = venv_path + '/bin/activate_this.py'
-    exec(open(activate_path).read(), dict(__file__=activate_path))
-$$ LANGUAGE plpythonu;
--- Internal function.
--- Set the seeds of the RNGs (Random Number Generators)
--- used internally.
-CREATE OR REPLACE FUNCTION
-_cdb_random_seeds (seed_value INTEGER) RETURNS VOID
-AS $$
-  plpy.execute('SELECT cdb_crankshaft._cdb_crankshaft_activate_py()')
-  from crankshaft import random_seeds
-  random_seeds.set_random_seeds(seed_value)
-$$ LANGUAGE plpythonu;
--- Moran's I
-CREATE OR REPLACE FUNCTION
-  cdb_moran_local (
-      t TEXT,
-  	  attr TEXT,
-  	  significance float DEFAULT 0.05,
-  	  num_ngbrs INT DEFAULT 5,
-  	  permutations INT DEFAULT 99,
-  	  geom_column TEXT DEFAULT 'the_geom',
-  	  id_col TEXT DEFAULT 'cartodb_id',
-      w_type TEXT DEFAULT 'knn')
-RETURNS TABLE (moran FLOAT, quads TEXT, significance FLOAT, ids INT)
-AS $$
-  plpy.execute('SELECT cdb_crankshaft._cdb_crankshaft_activate_py()')
-  from crankshaft.clustering import moran_local
-  # TODO: use named parameters or a dictionary
-  return moran_local(t, attr, significance, num_ngbrs, permutations, geom_column, id_col, w_type)
-$$ LANGUAGE plpythonu;
-
--- Moran's I Local Rate
-CREATE OR REPLACE FUNCTION
-  cdb_moran_local_rate(t TEXT,
-		 numerator TEXT,
-		 denominator TEXT,
-		 significance FLOAT DEFAULT 0.05,
-		 num_ngbrs INT DEFAULT 5,
-		 permutations INT DEFAULT 99,
-		 geom_column TEXT DEFAULT 'the_geom',
-		 id_col TEXT DEFAULT 'cartodb_id',
-		 w_type TEXT DEFAULT 'knn')
-RETURNS TABLE(moran FLOAT, quads TEXT, significance FLOAT, ids INT, y numeric)
-AS $$
-  plpy.execute('SELECT cdb_crankshaft._cdb_crankshaft_activate_py()')
-  from crankshaft.clustering import moran_local_rate
-  # TODO: use named parameters or a dictionary
-  return moran_local_rate(t, numerator, denominator, significance, num_ngbrs, permutations, geom_column, id_col, w_type)
-$$ LANGUAGE plpythonu;
--- Function by Stuart Lynn for a simple interpolation of a value
--- from a polygon table over an arbitrary polygon
--- (weighted by the area proportion overlapped)
--- Aereal weighting is a very simple form of aereal interpolation.
---
--- Parameters:
---   * geom a Polygon geometry which defines the area where a value will be
---     estimated as the area-weighted sum of a given table/column
---   * target_table_name table name of the table that provides the values
---   * target_column column name of the column that provides the values
---   * schema_name optional parameter to defina the schema the target table
---     belongs to, which is necessary if its not in the search_path.
---     Note that target_table_name should never include the schema in it.
--- Return value:
---   Aereal-weighted interpolation of the column values over the geometry
-CREATE OR REPLACE
-FUNCTION cdb_overlap_sum(geom geometry, target_table_name text, target_column text, schema_name text DEFAULT NULL)
-  RETURNS numeric AS
-$$
-DECLARE
-	result numeric;
-  qualified_name text;
-BEGIN
-  IF schema_name IS NULL THEN
-    qualified_name := Format('%I', target_table_name);
-  ELSE
-    qualified_name := Format('%I.%s', schema_name, target_table_name);
-  END IF;
-  EXECUTE Format('
-    SELECT sum(%I*ST_Area(St_Intersection($1, a.the_geom))/ST_Area(a.the_geom))
-    FROM %s AS a
-    WHERE $1 && a.the_geom
-  ', target_column, qualified_name)
-  USING geom
-  INTO result;
-  RETURN result;
-END;
-$$ LANGUAGE plpgsql;
---
--- Creates N points randomly distributed arround the polygon
---
--- @param g - the geometry to be turned in to points
---
--- @param no_points - the number of points to generate
---
--- @params max_iter_per_point - the function generates points in the polygon's bounding box
--- and discards points which don't lie in the polygon. max_iter_per_point specifies how many
--- misses per point the funciton accepts before giving up.
---
--- Returns: Multipoint with the requested points
-CREATE OR REPLACE FUNCTION cdb_dot_density(geom geometry , no_points Integer, max_iter_per_point Integer DEFAULT 1000)
-RETURNS GEOMETRY AS $$
-DECLARE
-  extent GEOMETRY;
-  test_point Geometry;
-  width                NUMERIC;
-  height               NUMERIC;
-  x0                   NUMERIC;
-  y0                   NUMERIC;
-  xp                   NUMERIC;
-  yp                   NUMERIC;
-  no_left              INTEGER;
-  remaining_iterations INTEGER;
-  points               GEOMETRY[];
-  bbox_line            GEOMETRY;
-  intersection_line    GEOMETRY;
-BEGIN
-  extent  := ST_Envelope(geom);
-  width   := ST_XMax(extent) - ST_XMIN(extent);
-  height  := ST_YMax(extent) - ST_YMIN(extent);
-  x0 	  := ST_XMin(extent);
-  y0 	  := ST_YMin(extent);
-  no_left := no_points;
-
-  LOOP
-    if(no_left=0) THEN
-      EXIT;
-    END IF;
-    yp = y0 + height*random();
-    bbox_line  = ST_MakeLine(
-      ST_SetSRID(ST_MakePoint(yp, x0),4326),
-      ST_SetSRID(ST_MakePoint(yp, x0+width),4326)
-    );
-    intersection_line = ST_Intersection(bbox_line,geom);
-  	test_point = ST_LineInterpolatePoint(st_makeline(st_linemerge(intersection_line)),random());
-	  points := points || test_point;
-	  no_left = no_left - 1 ;
-  END LOOP;
-  RETURN ST_Collect(points);
-END;
-$$
-LANGUAGE plpgsql VOLATILE;
--- Make sure by default there are no permissions for publicuser
--- NOTE: this happens at extension creation time, as part of an implicit transaction.
--- REVOKE ALL PRIVILEGES ON SCHEMA cdb_crankshaft FROM PUBLIC, publicuser CASCADE;
-
--- Grant permissions on the schema to publicuser (but just the schema)
-GRANT USAGE ON SCHEMA cdb_crankshaft TO publicuser;
-
--- Revoke execute permissions on all functions in the schema by default
--- REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_crankshaft FROM PUBLIC, publicuser;

release/crankshaft--0.0.3--0.0.2.sql

@@ -1,209 +0,0 @@
---DO NOT MODIFY THIS FILE, IT IS GENERATED AUTOMATICALLY FROM SOURCES
--- Complain if script is sourced in psql, rather than via CREATE EXTENSION
-\echo Use "CREATE EXTENSION crankshaft" to load this file. \quit
-
--- [MANUALLY] DROP FUNCTIONS INTRODUCED IN 0.0.3 version
-
-DROP FUNCTION IF EXISTS CDB_AreasOfInterestGlobal(TEXT,TEXT,TEXT,INT,INT,TEXT,TEXT);
-DROP FUNCTION IF EXISTS _CDB_AreasOfInterestLocal(TEXT,TEXT,TEXT,INT,INT,TEXT,TEXT);
-DROP FUNCTION IF EXISTS CDB_AreasOfInterestLocal(TEXT,TEXT,TEXT,INT,INT,TEXT,TEXT);
-DROP FUNCTION IF EXISTS CDB_GetSpatialHotspots(TEXT,TEXT,TEXT,INT,INT,TEXT,TEXT);
-DROP FUNCTION IF EXISTS CDB_GetSpatialColdspots(TEXT,TEXT,TEXT,INT,INT,TEXT,TEXT);
-DROP FUNCTION IF EXISTS CDB_GetSpatialOutliers(TEXT,TEXT,TEXT,INT,INT,TEXT,TEXT);
-DROP FUNCTION IF EXISTS CDB_AreasOfInterestGlobalRate(TEXT,TEXT,TEXT,TEXT,INT,INT,TEXT,TEXT);
-DROP FUNCTION IF EXISTS CDB_AreasOfInterestLocalRate(TEXT,TEXT,TEXT,TEXT,INT,INT,TEXT,TEXT);
-DROP FUNCTION IF EXISTS _CDB_AreasOfInterestLocalRate(TEXT,TEXT,TEXT,TEXT,INT,INT,TEXT,TEXT);
-DROP FUNCTION IF EXISTS CDB_GetSpatialHotspotsRate(TEXT,TEXT,TEXT,TEXT,INT,INT,TEXT,TEXT);
-DROP FUNCTION IF EXISTS CDB_GetSpatialColdspotsRate(TEXT,TEXT,TEXT,TEXT,INT,INT,TEXT,TEXT);
-DROP FUNCTION IF EXISTS CDB_GetSpatialOutliersRate(TEXT,TEXT,TEXT,TEXT,INT,INT,TEXT,TEXT);
-DROP FUNCTION IF EXISTS CDB_KMeans(text,integer,integer);
-DROP AGGREGATE IF EXISTS CDB_WeightedMean(geometry(Point, 4326), NUMERIC);
-DROP FUNCTION IF EXISTS CDB_WeightedMeanS(Numeric[], GEOMETRY(Point, 4326), NUMERIC);
-DROP FUNCTION IF EXISTS CDB_WeightedMeanF(Numeric[]);
-
-
--- [END MANUALLY] DROP FUNCTIONS INTRODUCED IN 0.0.3 version
-
--- Version number of the extension release
-CREATE OR REPLACE FUNCTION cdb_crankshaft_version()
-RETURNS text AS $$
-  SELECT '0.0.2'::text;
-$$ language 'sql' STABLE STRICT;
-
--- Internal identifier of the installed extension instence
--- e.g. 'dev' for current development version
-CREATE OR REPLACE FUNCTION _cdb_crankshaft_internal_version()
-RETURNS text AS $$
-  SELECT installed_version FROM pg_available_extensions where name='crankshaft' and pg_available_extensions IS NOT NULL;
-$$ language 'sql' STABLE STRICT;
-CREATE OR REPLACE FUNCTION _cdb_crankshaft_virtualenvs_path()
-RETURNS text
-AS $$
-  BEGIN
-    -- RETURN '/opt/virtualenvs/crankshaft';
-    RETURN '/home/ubuntu/crankshaft/envs';
-  END;
-$$ language plpgsql IMMUTABLE STRICT;
-
--- Use the crankshaft python module
-CREATE OR REPLACE FUNCTION _cdb_crankshaft_activate_py()
-RETURNS VOID
-AS $$
-    import os
-    # plpy.notice('%',str(os.environ))
-    # activate virtualenv
-    crankshaft_version = plpy.execute('SELECT cdb_crankshaft._cdb_crankshaft_internal_version()')[0]['_cdb_crankshaft_internal_version']
-    base_path = plpy.execute('SELECT cdb_crankshaft._cdb_crankshaft_virtualenvs_path()')[0]['_cdb_crankshaft_virtualenvs_path']
-    default_venv_path = os.path.join(base_path, crankshaft_version)
-    venv_path =  os.environ.get('CRANKSHAFT_VENV', default_venv_path)
-    activate_path = venv_path + '/bin/activate_this.py'
-    exec(open(activate_path).read(), dict(__file__=activate_path))
-$$ LANGUAGE plpythonu;
--- Internal function.
--- Set the seeds of the RNGs (Random Number Generators)
--- used internally.
-CREATE OR REPLACE FUNCTION
-_cdb_random_seeds (seed_value INTEGER) RETURNS VOID
-AS $$
-  plpy.execute('SELECT cdb_crankshaft._cdb_crankshaft_activate_py()')
-  from crankshaft import random_seeds
-  random_seeds.set_random_seeds(seed_value)
-$$ LANGUAGE plpythonu;
--- Moran's I
-CREATE OR REPLACE FUNCTION
-  cdb_moran_local (
-      t TEXT,
-  	  attr TEXT,
-  	  significance float DEFAULT 0.05,
-  	  num_ngbrs INT DEFAULT 5,
-  	  permutations INT DEFAULT 99,
-  	  geom_column TEXT DEFAULT 'the_geom',
-  	  id_col TEXT DEFAULT 'cartodb_id',
-      w_type TEXT DEFAULT 'knn')
-RETURNS TABLE (moran FLOAT, quads TEXT, significance FLOAT, ids INT)
-AS $$
-  plpy.execute('SELECT cdb_crankshaft._cdb_crankshaft_activate_py()')
-  from crankshaft.clustering import moran_local
-  # TODO: use named parameters or a dictionary
-  return moran_local(t, attr, significance, num_ngbrs, permutations, geom_column, id_col, w_type)
-$$ LANGUAGE plpythonu;
-
--- Moran's I Local Rate
-CREATE OR REPLACE FUNCTION
-  cdb_moran_local_rate(t TEXT,
-		 numerator TEXT,
-		 denominator TEXT,
-		 significance FLOAT DEFAULT 0.05,
-		 num_ngbrs INT DEFAULT 5,
-		 permutations INT DEFAULT 99,
-		 geom_column TEXT DEFAULT 'the_geom',
-		 id_col TEXT DEFAULT 'cartodb_id',
-		 w_type TEXT DEFAULT 'knn')
-RETURNS TABLE(moran FLOAT, quads TEXT, significance FLOAT, ids INT, y numeric)
-AS $$
-  plpy.execute('SELECT cdb_crankshaft._cdb_crankshaft_activate_py()')
-  from crankshaft.clustering import moran_local_rate
-  # TODO: use named parameters or a dictionary
-  return moran_local_rate(t, numerator, denominator, significance, num_ngbrs, permutations, geom_column, id_col, w_type)
-$$ LANGUAGE plpythonu;
--- Function by Stuart Lynn for a simple interpolation of a value
--- from a polygon table over an arbitrary polygon
--- (weighted by the area proportion overlapped)
--- Aereal weighting is a very simple form of aereal interpolation.
---
--- Parameters:
---   * geom a Polygon geometry which defines the area where a value will be
---     estimated as the area-weighted sum of a given table/column
---   * target_table_name table name of the table that provides the values
---   * target_column column name of the column that provides the values
---   * schema_name optional parameter to defina the schema the target table
---     belongs to, which is necessary if its not in the search_path.
---     Note that target_table_name should never include the schema in it.
--- Return value:
---   Aereal-weighted interpolation of the column values over the geometry
-CREATE OR REPLACE
-FUNCTION cdb_overlap_sum(geom geometry, target_table_name text, target_column text, schema_name text DEFAULT NULL)
-  RETURNS numeric AS
-$$
-DECLARE
-	result numeric;
-  qualified_name text;
-BEGIN
-  IF schema_name IS NULL THEN
-    qualified_name := Format('%I', target_table_name);
-  ELSE
-    qualified_name := Format('%I.%s', schema_name, target_table_name);
-  END IF;
-  EXECUTE Format('
-    SELECT sum(%I*ST_Area(St_Intersection($1, a.the_geom))/ST_Area(a.the_geom))
-    FROM %s AS a
-    WHERE $1 && a.the_geom
-  ', target_column, qualified_name)
-  USING geom
-  INTO result;
-  RETURN result;
-END;
-$$ LANGUAGE plpgsql;
---
--- Creates N points randomly distributed arround the polygon
---
--- @param g - the geometry to be turned in to points
---
--- @param no_points - the number of points to generate
---
--- @params max_iter_per_point - the function generates points in the polygon's bounding box
--- and discards points which don't lie in the polygon. max_iter_per_point specifies how many
--- misses per point the funciton accepts before giving up.
---
--- Returns: Multipoint with the requested points
-CREATE OR REPLACE FUNCTION cdb_dot_density(geom geometry , no_points Integer, max_iter_per_point Integer DEFAULT 1000)
-RETURNS GEOMETRY AS $$
-DECLARE
-  extent GEOMETRY;
-  test_point Geometry;
-  width                NUMERIC;
-  height               NUMERIC;
-  x0                   NUMERIC;
-  y0                   NUMERIC;
-  xp                   NUMERIC;
-  yp                   NUMERIC;
-  no_left              INTEGER;
-  remaining_iterations INTEGER;
-  points               GEOMETRY[];
-  bbox_line            GEOMETRY;
-  intersection_line    GEOMETRY;
-BEGIN
-  extent  := ST_Envelope(geom);
-  width   := ST_XMax(extent) - ST_XMIN(extent);
-  height  := ST_YMax(extent) - ST_YMIN(extent);
-  x0 	  := ST_XMin(extent);
-  y0 	  := ST_YMin(extent);
-  no_left := no_points;
-
-  LOOP
-    if(no_left=0) THEN
-      EXIT;
-    END IF;
-    yp = y0 + height*random();
-    bbox_line  = ST_MakeLine(
-      ST_SetSRID(ST_MakePoint(yp, x0),4326),
-      ST_SetSRID(ST_MakePoint(yp, x0+width),4326)
-    );
-    intersection_line = ST_Intersection(bbox_line,geom);
-  	test_point = ST_LineInterpolatePoint(st_makeline(st_linemerge(intersection_line)),random());
-	  points := points || test_point;
-	  no_left = no_left - 1 ;
-  END LOOP;
-  RETURN ST_Collect(points);
-END;
-$$
-LANGUAGE plpgsql VOLATILE;
--- Make sure by default there are no permissions for publicuser
--- NOTE: this happens at extension creation time, as part of an implicit transaction.
--- REVOKE ALL PRIVILEGES ON SCHEMA cdb_crankshaft FROM PUBLIC, publicuser CASCADE;
-
--- Grant permissions on the schema to publicuser (but just the schema)
-GRANT USAGE ON SCHEMA cdb_crankshaft TO publicuser;
-
--- Revoke execute permissions on all functions in the schema by default
--- REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_crankshaft FROM PUBLIC, publicuser;

release/crankshaft--0.0.3--0.0.4.sql

@@ -1,8 +0,0 @@
---DO NOT MODIFY THIS FILE, IT IS GENERATED AUTOMATICALLY FROM SOURCES
--- Complain if script is sourced in psql, rather than via CREATE EXTENSION
-\echo Use "CREATE EXTENSION crankshaft" to load this file. \quit
--- Version number of the extension release
-CREATE OR REPLACE FUNCTION cdb_crankshaft_version()
-RETURNS text AS $$
-  SELECT '0.0.4'::text;
-$$ language 'sql' STABLE STRICT;

release/crankshaft--0.0.3.sql

@@ -1,403 +0,0 @@
---DO NOT MODIFY THIS FILE, IT IS GENERATED AUTOMATICALLY FROM SOURCES
--- Complain if script is sourced in psql, rather than via CREATE EXTENSION
-\echo Use "CREATE EXTENSION crankshaft" to load this file. \quit
--- Version number of the extension release
-CREATE OR REPLACE FUNCTION cdb_crankshaft_version()
-RETURNS text AS $$
-  SELECT '0.0.3'::text;
-$$ language 'sql' STABLE STRICT;
-
--- Internal identifier of the installed extension instence
--- e.g. 'dev' for current development version
-CREATE OR REPLACE FUNCTION _cdb_crankshaft_internal_version()
-RETURNS text AS $$
-  SELECT installed_version FROM pg_available_extensions where name='crankshaft' and pg_available_extensions IS NOT NULL;
-$$ language 'sql' STABLE STRICT;
--- Internal function.
--- Set the seeds of the RNGs (Random Number Generators)
--- used internally.
-CREATE OR REPLACE FUNCTION
-_cdb_random_seeds (seed_value INTEGER) RETURNS VOID
-AS $$
-  from crankshaft import random_seeds
-  random_seeds.set_random_seeds(seed_value)
-$$ LANGUAGE plpythonu;
--- Moran's I Global Measure (public-facing)
-CREATE OR REPLACE FUNCTION
-  CDB_AreasOfInterestGlobal(
-      subquery TEXT,
-      column_name TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS TABLE (moran NUMERIC, significance NUMERIC)
-AS $$
-  from crankshaft.clustering import moran_local
-  # TODO: use named parameters or a dictionary
-  return moran(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
--- Moran's I Local (internal function)
-CREATE OR REPLACE FUNCTION
-  _CDB_AreasOfInterestLocal(
-      subquery TEXT,
-      column_name TEXT,
-      w_type TEXT,
-      num_ngbrs INT,
-      permutations INT,
-      geom_col TEXT,
-      id_col TEXT)
-RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-  from crankshaft.clustering import moran_local
-  # TODO: use named parameters or a dictionary
-  return moran_local(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
--- Moran's I Local (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_AreasOfInterestLocal(
-    subquery TEXT,
-    column_name TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col);
-
-$$ LANGUAGE SQL;
-
--- Moran's I only for HH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialHotspots(
-    subquery TEXT,
-    column_name TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HH', 'HL');
-
-$$ LANGUAGE SQL;
-
--- Moran's I only for LL and LH (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialColdspots(
-    subquery TEXT,
-    attr TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, attr, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('LL', 'LH');
-
-$$ LANGUAGE SQL;
-
--- Moran's I only for LH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialOutliers(
-    subquery TEXT,
-    attr TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, attr, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HL', 'LH');
-
-$$ LANGUAGE SQL;
-
--- Moran's I Global Rate (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_AreasOfInterestGlobalRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS TABLE (moran FLOAT, significance FLOAT)
-AS $$
-  from crankshaft.clustering import moran_local
-  # TODO: use named parameters or a dictionary
-  return moran_rate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
-
--- Moran's I Local Rate (internal function)
-CREATE OR REPLACE FUNCTION
-  _CDB_AreasOfInterestLocalRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT,
-      num_ngbrs INT,
-      permutations INT,
-      geom_col TEXT,
-      id_col TEXT)
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-  from crankshaft.clustering import moran_local_rate
-  # TODO: use named parameters or a dictionary
-  return moran_local_rate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
--- Moran's I Local Rate (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_AreasOfInterestLocalRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col);
-
-$$ LANGUAGE SQL;
-
--- Moran's I Local Rate only for HH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialHotspotsRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HH', 'HL');
-
-$$ LANGUAGE SQL;
-
--- Moran's I Local Rate only for LL and LH (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialColdspotsRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('LL', 'LH');
-
-$$ LANGUAGE SQL;
-
--- Moran's I Local Rate only for LH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialOutliersRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HL', 'LH');
-
-$$ LANGUAGE SQL;
-CREATE OR REPLACE FUNCTION  CDB_KMeans(query text, no_clusters integer,no_init integer default 20)
-RETURNS table (cartodb_id integer, cluster_no integer) as $$
-    
-    from crankshaft.clustering import kmeans
-    return kmeans(query,no_clusters,no_init)
-
-$$ language plpythonu;
-
-
-CREATE OR REPLACE FUNCTION CDB_WeightedMeanS(state Numeric[],the_geom GEOMETRY(Point, 4326), weight NUMERIC)
-RETURNS Numeric[] AS 
-$$
-DECLARE 
-    newX NUMERIC;
-    newY NUMERIC;
-    newW NUMERIC;
-BEGIN
-    IF weight IS NULL OR the_geom IS NULL THEN 
-        newX = state[1];
-        newY = state[2];
-        newW = state[3];
-    ELSE
-        newX = state[1] + ST_X(the_geom)*weight;
-        newY = state[2] + ST_Y(the_geom)*weight;
-        newW = state[3] + weight;
-    END IF;
-    RETURN Array[newX,newY,newW];
-
-END
-$$ LANGUAGE plpgsql;
-
-CREATE OR REPLACE FUNCTION CDB_WeightedMeanF(state Numeric[])
-RETURNS GEOMETRY AS 
-$$
-BEGIN
-    IF state[3] = 0 THEN 
-        RETURN ST_SetSRID(ST_MakePoint(state[1],state[2]), 4326);
-    ELSE 
-        RETURN ST_SETSRID(ST_MakePoint(state[1]/state[3], state[2]/state[3]),4326);
-    END IF;
-END
-$$ LANGUAGE plpgsql;
-
-CREATE AGGREGATE CDB_WeightedMean(geometry(Point, 4326), NUMERIC)(
-    SFUNC = CDB_WeightedMeanS,
-    FINALFUNC = CDB_WeightedMeanF,
-    STYPE = Numeric[],
-    INITCOND = "{0.0,0.0,0.0}" 
-);
--- Function by Stuart Lynn for a simple interpolation of a value
--- from a polygon table over an arbitrary polygon
--- (weighted by the area proportion overlapped)
--- Aereal weighting is a very simple form of aereal interpolation.
---
--- Parameters:
---   * geom a Polygon geometry which defines the area where a value will be
---     estimated as the area-weighted sum of a given table/column
---   * target_table_name table name of the table that provides the values
---   * target_column column name of the column that provides the values
---   * schema_name optional parameter to defina the schema the target table
---     belongs to, which is necessary if its not in the search_path.
---     Note that target_table_name should never include the schema in it.
--- Return value:
---   Aereal-weighted interpolation of the column values over the geometry
-CREATE OR REPLACE
-FUNCTION cdb_overlap_sum(geom geometry, target_table_name text, target_column text, schema_name text DEFAULT NULL)
-  RETURNS numeric AS
-$$
-DECLARE
-	result numeric;
-  qualified_name text;
-BEGIN
-  IF schema_name IS NULL THEN
-    qualified_name := Format('%I', target_table_name);
-  ELSE
-    qualified_name := Format('%I.%s', schema_name, target_table_name);
-  END IF;
-  EXECUTE Format('
-    SELECT sum(%I*ST_Area(St_Intersection($1, a.the_geom))/ST_Area(a.the_geom))
-    FROM %s AS a
-    WHERE $1 && a.the_geom
-  ', target_column, qualified_name)
-  USING geom
-  INTO result;
-  RETURN result;
-END;
-$$ LANGUAGE plpgsql;
---
--- Creates N points randomly distributed arround the polygon
---
--- @param g - the geometry to be turned in to points
---
--- @param no_points - the number of points to generate
---
--- @params max_iter_per_point - the function generates points in the polygon's bounding box
--- and discards points which don't lie in the polygon. max_iter_per_point specifies how many
--- misses per point the funciton accepts before giving up.
---
--- Returns: Multipoint with the requested points
-CREATE OR REPLACE FUNCTION cdb_dot_density(geom geometry , no_points Integer, max_iter_per_point Integer DEFAULT 1000)
-RETURNS GEOMETRY AS $$
-DECLARE
-  extent GEOMETRY;
-  test_point Geometry;
-  width                NUMERIC;
-  height               NUMERIC;
-  x0                   NUMERIC;
-  y0                   NUMERIC;
-  xp                   NUMERIC;
-  yp                   NUMERIC;
-  no_left              INTEGER;
-  remaining_iterations INTEGER;
-  points               GEOMETRY[];
-  bbox_line            GEOMETRY;
-  intersection_line    GEOMETRY;
-BEGIN
-  extent  := ST_Envelope(geom);
-  width   := ST_XMax(extent) - ST_XMIN(extent);
-  height  := ST_YMax(extent) - ST_YMIN(extent);
-  x0 	  := ST_XMin(extent);
-  y0 	  := ST_YMin(extent);
-  no_left := no_points;
-
-  LOOP
-    if(no_left=0) THEN
-      EXIT;
-    END IF;
-    yp = y0 + height*random();
-    bbox_line  = ST_MakeLine(
-      ST_SetSRID(ST_MakePoint(yp, x0),4326),
-      ST_SetSRID(ST_MakePoint(yp, x0+width),4326)
-    );
-    intersection_line = ST_Intersection(bbox_line,geom);
-  	test_point = ST_LineInterpolatePoint(st_makeline(st_linemerge(intersection_line)),random());
-	  points := points || test_point;
-	  no_left = no_left - 1 ;
-  END LOOP;
-  RETURN ST_Collect(points);
-END;
-$$
-LANGUAGE plpgsql VOLATILE;
--- Make sure by default there are no permissions for publicuser
--- NOTE: this happens at extension creation time, as part of an implicit transaction.
--- REVOKE ALL PRIVILEGES ON SCHEMA cdb_crankshaft FROM PUBLIC, publicuser CASCADE;
-
--- Grant permissions on the schema to publicuser (but just the schema)
-GRANT USAGE ON SCHEMA cdb_crankshaft TO publicuser;
-
--- Revoke execute permissions on all functions in the schema by default
--- REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_crankshaft FROM PUBLIC, publicuser;

release/crankshaft--0.0.4--0.0.3.sql

@@ -1,8 +0,0 @@
---DO NOT MODIFY THIS FILE, IT IS GENERATED AUTOMATICALLY FROM SOURCES
--- Complain if script is sourced in psql, rather than via CREATE EXTENSION
-\echo Use "CREATE EXTENSION crankshaft" to load this file. \quit
--- Version number of the extension release
-CREATE OR REPLACE FUNCTION cdb_crankshaft_version()
-RETURNS text AS $$
-  SELECT '0.0.3'::text;
-$$ language 'sql' STABLE STRICT;

release/crankshaft--0.0.4--0.1.0.sql

@@ -1,258 +0,0 @@
---DO NOT MODIFY THIS FILE, IT IS GENERATED FROM SOURCES
-
--- Complain if script is sourced in psql, rather than via CREATE EXTENSION
-\echo Use "CREATE EXTENSION crankshaft" to load this file. \quit
-
---------------------------------------------------------------------------------
-
--- Version number of the extension release
-CREATE OR REPLACE FUNCTION cdb_crankshaft_version()
-RETURNS text AS $$
-  SELECT '0.1.0'::text;
-$$ language 'sql' STABLE STRICT;
-
---------------------------------------------------------------------------------
-
--- PyAgg stuff
-CREATE OR REPLACE FUNCTION
-    CDB_PyAggS(current_state Numeric[], current_row Numeric[]) 
-    returns NUMERIC[] as $$
-    BEGIN
-        if array_upper(current_state,1) is null  then
-            RAISE NOTICE 'setting state %',array_upper(current_row,1);
-            current_state[1] = array_upper(current_row,1);
-        end if;
-        return array_cat(current_state,current_row) ;
-    END
-    $$ LANGUAGE plpgsql;
-
-
-CREATE AGGREGATE CDB_PyAgg(NUMERIC[])(
-    SFUNC = CDB_PyAggS,
-    STYPE = Numeric[],
-    INITCOND = "{}" 
-);
-
---------------------------------------------------------------------------------
-
--- Segmentation stuff
-CREATE OR REPLACE FUNCTION
-  CDB_CreateAndPredictSegment(
-    target NUMERIC[],
-    features NUMERIC[],
-    target_features NUMERIC[],
-    target_ids NUMERIC[],
-    n_estimators INTEGER DEFAULT 1200,
-    max_depth INTEGER DEFAULT 3,
-    subsample DOUBLE PRECISION DEFAULT 0.5,
-    learning_rate DOUBLE PRECISION DEFAULT 0.01,
-    min_samples_leaf INTEGER DEFAULT 1)
-RETURNS TABLE(cartodb_id NUMERIC, prediction NUMERIC, accuracy NUMERIC)
-AS $$
-    import numpy as np
-    import plpy
-
-    from crankshaft.segmentation import create_and_predict_segment_agg
-    model_params = {'n_estimators': n_estimators,
-                    'max_depth': max_depth,
-                    'subsample': subsample,
-                    'learning_rate': learning_rate,
-                    'min_samples_leaf': min_samples_leaf}
-
-    def unpack2D(data):
-        dimension = data.pop(0)
-        a = np.array(data, dtype=float)
-        return a.reshape(len(a)/dimension, dimension)
-
-    return create_and_predict_segment_agg(np.array(target, dtype=float),
-            unpack2D(features),
-            unpack2D(target_features),
-            target_ids,
-            model_params)
-
-$$ LANGUAGE plpythonu;
-
-CREATE OR REPLACE FUNCTION
-  CDB_CreateAndPredictSegment (
-      query TEXT,
-      variable_name TEXT,
-      target_table TEXT,
-      n_estimators INTEGER DEFAULT 1200,
-      max_depth INTEGER DEFAULT 3,
-      subsample DOUBLE PRECISION DEFAULT 0.5,
-      learning_rate DOUBLE PRECISION DEFAULT 0.01,
-      min_samples_leaf INTEGER DEFAULT 1)
-RETURNS TABLE (cartodb_id TEXT, prediction NUMERIC, accuracy NUMERIC)
-AS $$
-  from crankshaft.segmentation import create_and_predict_segment
-  model_params = {'n_estimators': n_estimators, 'max_depth':max_depth, 'subsample' : subsample, 'learning_rate': learning_rate, 'min_samples_leaf' : min_samples_leaf}
-  return create_and_predict_segment(query,variable_name,target_table, model_params)
-$$ LANGUAGE plpythonu;
-
---------------------------------------------------------------------------------
-
--- Spatial interpolation
-
--- 0: nearest neighbor
--- 1: barymetric
--- 2: IDW
-
-CREATE OR REPLACE FUNCTION CDB_SpatialInterpolation(
-    IN query text,
-    IN point geometry,
-    IN method integer DEFAULT 1,
-    IN p1 numeric DEFAULT 0,
-    IN p2 numeric DEFAULT 0
-    )
-RETURNS numeric AS
-$$
-DECLARE
-    gs geometry[];
-    vs numeric[];
-    output numeric;
-BEGIN
-    EXECUTE 'WITH a AS('||query||') SELECT array_agg(the_geom), array_agg(attrib) FROM a' INTO gs, vs;
-    SELECT CDB_SpatialInterpolation(gs, vs, point, method, p1,p2) INTO output FROM a;
-
-    RETURN output;
-END;
-$$
-language plpgsql IMMUTABLE;
-
-CREATE OR REPLACE FUNCTION CDB_SpatialInterpolation(
-    IN geomin geometry[],
-    IN colin numeric[],
-    IN point geometry,
-    IN method integer DEFAULT 1,
-    IN p1 numeric DEFAULT 0,
-    IN p2 numeric DEFAULT 0
-    )
-RETURNS numeric AS
-$$
-DECLARE
-    gs geometry[];
-    vs numeric[];
-    gs2 geometry[];
-    vs2 numeric[];
-    g geometry;
-    vertex geometry[];
-    sg numeric;
-    sa numeric;
-    sb numeric;
-    sc numeric;
-    va numeric;
-    vb numeric;
-    vc numeric;
-    output numeric;
-BEGIN
-    output :=  -999.999;
-    -- nearest
-    IF method = 0 THEN
-
-        WITH    a as (SELECT unnest(geomin) as g, unnest(colin) as v)
-        SELECT a.v INTO output FROM a ORDER BY point<->a.g LIMIT 1;
-        RETURN output;
-
-    -- barymetric
-    ELSIF method = 1 THEN
-        WITH    a as (SELECT unnest(geomin) AS e),
-                b as (SELECT ST_DelaunayTriangles(ST_Collect(a.e),0.001, 0) AS t FROM a),
-                c as (SELECT (ST_Dump(t)).geom as v FROM b),
-                d as (SELECT v FROM c WHERE ST_Within(point, v))
-            SELECT v INTO g FROM d;
-        IF g is null THEN
-            -- out of the realm of the input data
-            RETURN -888.888;
-        END IF;
-        -- vertex of the selected cell
-        WITH a AS (SELECT (ST_DumpPoints(g)).geom AS v)
-                SELECT array_agg(v) INTO vertex FROM a;
-
-            -- retrieve the value of each vertex
-        WITH a AS(SELECT unnest(vertex) as geo, unnest(colin) as c)
-            SELECT c INTO va FROM a WHERE ST_Equals(geo, vertex[1]);
-        WITH a AS(SELECT unnest(vertex) as geo, unnest(colin) as c)
-            SELECT c INTO vb FROM a WHERE ST_Equals(geo, vertex[2]);
-        WITH a AS(SELECT unnest(vertex) as geo, unnest(colin) as c)
-                SELECT c INTO vc FROM a WHERE ST_Equals(geo, vertex[3]);
-
-        SELECT ST_area(g), ST_area(ST_MakePolygon(ST_MakeLine(ARRAY[point, vertex[2], vertex[3], point]))), ST_area(ST_MakePolygon(ST_MakeLine(ARRAY[point, vertex[1], vertex[3], point]))), ST_area(ST_MakePolygon(ST_MakeLine(ARRAY[point,vertex[1],vertex[2], point]))) INTO sg, sa, sb, sc;
-
-        output := (coalesce(sa,0) * coalesce(va,0) + coalesce(sb,0) * coalesce(vb,0) + coalesce(sc,0) * coalesce(vc,0)) / coalesce(sg);
-        RETURN output;
-
-    -- IDW
-    -- p1: limit the number of neighbors, 0->no limit
-    -- p2: order of distance decay, 0-> order 1
-    ELSIF method = 2 THEN
-
-        IF p2 = 0 THEN
-            p2 := 1;
-        END IF;
-
-        WITH    a as (SELECT unnest(geomin) as g, unnest(colin) as v),
-                b as (SELECT a.g, a.v FROM a ORDER BY point<->a.g)
-        SELECT array_agg(b.g), array_agg(b.v) INTO gs, vs FROM b;
-        IF p1::integer>0 THEN
-            gs2:=gs;
-            vs2:=vs;
-            FOR i IN 1..p1
-            LOOP
-                gs2 := gs2 || gs[i];
-                vs2 := vs2 || vs[i];
-            END LOOP;
-        ELSE
-            gs2:=gs;
-            vs2:=vs;
-        END IF;
-
-        WITH    a as (SELECT unnest(gs2) as g, unnest(vs2) as v),
-                b as (
-                    SELECT
-                    (1/ST_distance(point, a.g)^p2::integer) as k,
-                    (a.v/ST_distance(point, a.g)^p2::integer) as f
-                    FROM a
-                )
-        SELECT sum(b.f)/sum(b.k) INTO output FROM b;
-        RETURN output;
-
-    END IF;
-
-    RETURN -777.777;
-
-END;
-$$
-language plpgsql IMMUTABLE;
-
-
---------------------------------------------------------------------------------
-
--- Spatial Markov
-
--- input table format:
--- id | geom | date_1 | date_2 | date_3
---  1 | Pt1  | 12.3   | 13.1   | 14.2
---  2 | Pt2  | 11.0   | 13.2   | 12.5
---  ...
--- Sample Function call:
--- SELECT CDB_SpatialMarkov('SELECT * FROM real_estate',
---                          Array['date_1', 'date_2', 'date_3'])
-
-CREATE OR REPLACE FUNCTION
-  CDB_SpatialMarkovTrend (
-      subquery TEXT,
-      time_cols TEXT[],
-      num_classes INT DEFAULT 7,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-  	  permutations INT DEFAULT 99,
-  	  geom_col TEXT DEFAULT 'the_geom',
-  	  id_col TEXT DEFAULT 'cartodb_id')
-RETURNS TABLE (trend NUMERIC, trend_up NUMERIC, trend_down NUMERIC, volatility NUMERIC, rowid INT)
-AS $$
-
-  from crankshaft.space_time_dynamics import spatial_markov_trend
-
-  ## TODO: use named parameters or a dictionary
-  return spatial_markov_trend(subquery, time_cols, num_classes, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;

release/crankshaft--0.0.4.sql

@@ -1,403 +0,0 @@
---DO NOT MODIFY THIS FILE, IT IS GENERATED AUTOMATICALLY FROM SOURCES
--- Complain if script is sourced in psql, rather than via CREATE EXTENSION
-\echo Use "CREATE EXTENSION crankshaft" to load this file. \quit
--- Version number of the extension release
-CREATE OR REPLACE FUNCTION cdb_crankshaft_version()
-RETURNS text AS $$
-  SELECT '0.0.4'::text;
-$$ language 'sql' STABLE STRICT;
-
--- Internal identifier of the installed extension instence
--- e.g. 'dev' for current development version
-CREATE OR REPLACE FUNCTION _cdb_crankshaft_internal_version()
-RETURNS text AS $$
-  SELECT installed_version FROM pg_available_extensions where name='crankshaft' and pg_available_extensions IS NOT NULL;
-$$ language 'sql' STABLE STRICT;
--- Internal function.
--- Set the seeds of the RNGs (Random Number Generators)
--- used internally.
-CREATE OR REPLACE FUNCTION
-_cdb_random_seeds (seed_value INTEGER) RETURNS VOID
-AS $$
-  from crankshaft import random_seeds
-  random_seeds.set_random_seeds(seed_value)
-$$ LANGUAGE plpythonu;
--- Moran's I Global Measure (public-facing)
-CREATE OR REPLACE FUNCTION
-  CDB_AreasOfInterestGlobal(
-      subquery TEXT,
-      column_name TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS TABLE (moran NUMERIC, significance NUMERIC)
-AS $$
-  from crankshaft.clustering import moran_local
-  # TODO: use named parameters or a dictionary
-  return moran(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
--- Moran's I Local (internal function)
-CREATE OR REPLACE FUNCTION
-  _CDB_AreasOfInterestLocal(
-      subquery TEXT,
-      column_name TEXT,
-      w_type TEXT,
-      num_ngbrs INT,
-      permutations INT,
-      geom_col TEXT,
-      id_col TEXT)
-RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-  from crankshaft.clustering import moran_local
-  # TODO: use named parameters or a dictionary
-  return moran_local(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
--- Moran's I Local (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_AreasOfInterestLocal(
-    subquery TEXT,
-    column_name TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col);
-
-$$ LANGUAGE SQL;
-
--- Moran's I only for HH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialHotspots(
-    subquery TEXT,
-    column_name TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HH', 'HL');
-
-$$ LANGUAGE SQL;
-
--- Moran's I only for LL and LH (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialColdspots(
-    subquery TEXT,
-    attr TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, attr, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('LL', 'LH');
-
-$$ LANGUAGE SQL;
-
--- Moran's I only for LH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialOutliers(
-    subquery TEXT,
-    attr TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, attr, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HL', 'LH');
-
-$$ LANGUAGE SQL;
-
--- Moran's I Global Rate (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_AreasOfInterestGlobalRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS TABLE (moran FLOAT, significance FLOAT)
-AS $$
-  from crankshaft.clustering import moran_local
-  # TODO: use named parameters or a dictionary
-  return moran_rate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
-
--- Moran's I Local Rate (internal function)
-CREATE OR REPLACE FUNCTION
-  _CDB_AreasOfInterestLocalRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT,
-      num_ngbrs INT,
-      permutations INT,
-      geom_col TEXT,
-      id_col TEXT)
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-  from crankshaft.clustering import moran_local_rate
-  # TODO: use named parameters or a dictionary
-  return moran_local_rate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
--- Moran's I Local Rate (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_AreasOfInterestLocalRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col);
-
-$$ LANGUAGE SQL;
-
--- Moran's I Local Rate only for HH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialHotspotsRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HH', 'HL');
-
-$$ LANGUAGE SQL;
-
--- Moran's I Local Rate only for LL and LH (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialColdspotsRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('LL', 'LH');
-
-$$ LANGUAGE SQL;
-
--- Moran's I Local Rate only for LH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialOutliersRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HL', 'LH');
-
-$$ LANGUAGE SQL;
-CREATE OR REPLACE FUNCTION  CDB_KMeans(query text, no_clusters integer,no_init integer default 20)
-RETURNS table (cartodb_id integer, cluster_no integer) as $$
-    
-    from crankshaft.clustering import kmeans
-    return kmeans(query,no_clusters,no_init)
-
-$$ language plpythonu;
-
-
-CREATE OR REPLACE FUNCTION CDB_WeightedMeanS(state Numeric[],the_geom GEOMETRY(Point, 4326), weight NUMERIC)
-RETURNS Numeric[] AS 
-$$
-DECLARE 
-    newX NUMERIC;
-    newY NUMERIC;
-    newW NUMERIC;
-BEGIN
-    IF weight IS NULL OR the_geom IS NULL THEN 
-        newX = state[1];
-        newY = state[2];
-        newW = state[3];
-    ELSE
-        newX = state[1] + ST_X(the_geom)*weight;
-        newY = state[2] + ST_Y(the_geom)*weight;
-        newW = state[3] + weight;
-    END IF;
-    RETURN Array[newX,newY,newW];
-
-END
-$$ LANGUAGE plpgsql;
-
-CREATE OR REPLACE FUNCTION CDB_WeightedMeanF(state Numeric[])
-RETURNS GEOMETRY AS 
-$$
-BEGIN
-    IF state[3] = 0 THEN 
-        RETURN ST_SetSRID(ST_MakePoint(state[1],state[2]), 4326);
-    ELSE 
-        RETURN ST_SETSRID(ST_MakePoint(state[1]/state[3], state[2]/state[3]),4326);
-    END IF;
-END
-$$ LANGUAGE plpgsql;
-
-CREATE AGGREGATE CDB_WeightedMean(geometry(Point, 4326), NUMERIC)(
-    SFUNC = CDB_WeightedMeanS,
-    FINALFUNC = CDB_WeightedMeanF,
-    STYPE = Numeric[],
-    INITCOND = "{0.0,0.0,0.0}" 
-);
--- Function by Stuart Lynn for a simple interpolation of a value
--- from a polygon table over an arbitrary polygon
--- (weighted by the area proportion overlapped)
--- Aereal weighting is a very simple form of aereal interpolation.
---
--- Parameters:
---   * geom a Polygon geometry which defines the area where a value will be
---     estimated as the area-weighted sum of a given table/column
---   * target_table_name table name of the table that provides the values
---   * target_column column name of the column that provides the values
---   * schema_name optional parameter to defina the schema the target table
---     belongs to, which is necessary if its not in the search_path.
---     Note that target_table_name should never include the schema in it.
--- Return value:
---   Aereal-weighted interpolation of the column values over the geometry
-CREATE OR REPLACE
-FUNCTION cdb_overlap_sum(geom geometry, target_table_name text, target_column text, schema_name text DEFAULT NULL)
-  RETURNS numeric AS
-$$
-DECLARE
-	result numeric;
-  qualified_name text;
-BEGIN
-  IF schema_name IS NULL THEN
-    qualified_name := Format('%I', target_table_name);
-  ELSE
-    qualified_name := Format('%I.%s', schema_name, target_table_name);
-  END IF;
-  EXECUTE Format('
-    SELECT sum(%I*ST_Area(St_Intersection($1, a.the_geom))/ST_Area(a.the_geom))
-    FROM %s AS a
-    WHERE $1 && a.the_geom
-  ', target_column, qualified_name)
-  USING geom
-  INTO result;
-  RETURN result;
-END;
-$$ LANGUAGE plpgsql;
---
--- Creates N points randomly distributed arround the polygon
---
--- @param g - the geometry to be turned in to points
---
--- @param no_points - the number of points to generate
---
--- @params max_iter_per_point - the function generates points in the polygon's bounding box
--- and discards points which don't lie in the polygon. max_iter_per_point specifies how many
--- misses per point the funciton accepts before giving up.
---
--- Returns: Multipoint with the requested points
-CREATE OR REPLACE FUNCTION cdb_dot_density(geom geometry , no_points Integer, max_iter_per_point Integer DEFAULT 1000)
-RETURNS GEOMETRY AS $$
-DECLARE
-  extent GEOMETRY;
-  test_point Geometry;
-  width                NUMERIC;
-  height               NUMERIC;
-  x0                   NUMERIC;
-  y0                   NUMERIC;
-  xp                   NUMERIC;
-  yp                   NUMERIC;
-  no_left              INTEGER;
-  remaining_iterations INTEGER;
-  points               GEOMETRY[];
-  bbox_line            GEOMETRY;
-  intersection_line    GEOMETRY;
-BEGIN
-  extent  := ST_Envelope(geom);
-  width   := ST_XMax(extent) - ST_XMIN(extent);
-  height  := ST_YMax(extent) - ST_YMIN(extent);
-  x0 	  := ST_XMin(extent);
-  y0 	  := ST_YMin(extent);
-  no_left := no_points;
-
-  LOOP
-    if(no_left=0) THEN
-      EXIT;
-    END IF;
-    yp = y0 + height*random();
-    bbox_line  = ST_MakeLine(
-      ST_SetSRID(ST_MakePoint(yp, x0),4326),
-      ST_SetSRID(ST_MakePoint(yp, x0+width),4326)
-    );
-    intersection_line = ST_Intersection(bbox_line,geom);
-  	test_point = ST_LineInterpolatePoint(st_makeline(st_linemerge(intersection_line)),random());
-	  points := points || test_point;
-	  no_left = no_left - 1 ;
-  END LOOP;
-  RETURN ST_Collect(points);
-END;
-$$
-LANGUAGE plpgsql VOLATILE;
--- Make sure by default there are no permissions for publicuser
--- NOTE: this happens at extension creation time, as part of an implicit transaction.
--- REVOKE ALL PRIVILEGES ON SCHEMA cdb_crankshaft FROM PUBLIC, publicuser CASCADE;
-
--- Grant permissions on the schema to publicuser (but just the schema)
-GRANT USAGE ON SCHEMA cdb_crankshaft TO publicuser;
-
--- Revoke execute permissions on all functions in the schema by default
--- REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_crankshaft FROM PUBLIC, publicuser;

release/crankshaft--0.1.0--0.0.4.sql

@@ -1,81 +0,0 @@
---DO NOT MODIFY THIS FILE, IT IS GENERATED FROM SOURCES
-
--- Complain if script is sourced in psql, rather than via CREATE EXTENSION
-\echo Use "CREATE EXTENSION crankshaft" to load this file. \quit
-
--- Version number of the extension release
-CREATE OR REPLACE FUNCTION cdb_crankshaft_version()
-RETURNS text AS $$
-  SELECT '0.0.4'::text;
-$$ language 'sql' STABLE STRICT;
-
---------------------------------------------------------------------------------
-
--- Spatial Markov
-
-DROP FUNCTION
-  CDB_SpatialMarkovTrend (
-      subquery TEXT,
-      time_cols TEXT[],
-      num_classes INT,
-      w_type TEXT,
-      num_ngbrs INT,
-  	  permutations INT,
-  	  geom_col TEXT,
-  	  id_col TEXT);
-
-
---------------------------------------------------------------------------------
-
--- Spatial interpolation
-
-DROP FUNCTION CDB_SpatialInterpolation(
-    IN geomin geometry[],
-    IN colin numeric[],
-    IN point geometry,
-    IN method integer,
-    IN p1 numeric,
-    IN p2 numeric
-    );
-
-DROP FUNCTION CDB_SpatialInterpolation(
-    IN query text,
-    IN point geometry,
-    IN method integer,
-    IN p1 numeric,
-    IN p2 numeric
-    );
-
---------------------------------------------------------------------------------
-
--- Segmentation stuff
-
-DROP FUNCTION
-  CDB_CreateAndPredictSegment (
-      query TEXT,
-      variable_name TEXT,
-      target_table TEXT,
-      n_estimators INTEGER,
-      max_depth INTEGER,
-      subsample DOUBLE PRECISION,
-      learning_rate DOUBLE PRECISION,
-      min_samples_leaf INTEGER);
-
-DROP FUNCTION
-  CDB_CreateAndPredictSegment(
-    target NUMERIC[],
-    features NUMERIC[],
-    target_features NUMERIC[],
-    target_ids NUMERIC[],
-    n_estimators INTEGER,
-    max_depth INTEGER,
-    subsample DOUBLE PRECISION,
-    learning_rate DOUBLE PRECISION,
-    min_samples_leaf INTEGER);
-
---------------------------------------------------------------------------------
-
--- PyAgg stuff
-
-DROP AGGREGATE CDB_PyAgg(NUMERIC[]);
-DROP FUNCTION CDB_PyAggS(Numeric[], Numeric[]);

release/crankshaft--0.1.0--0.2.0.sql

@@ -1,827 +0,0 @@
---DO NOT MODIFY THIS FILE, IT IS GENERATED AUTOMATICALLY FROM SOURCES
--- Complain if script is sourced in psql, rather than via CREATE EXTENSION
-\echo Use "CREATE EXTENSION crankshaft" to load this file. \quit
--- Version number of the extension release
-CREATE OR REPLACE FUNCTION cdb_crankshaft_version()
-RETURNS text AS $$
-  SELECT '0.2.0'::text;
-$$ language 'sql' STABLE STRICT;
-
--- Internal identifier of the installed extension instence
--- e.g. 'dev' for current development version
-CREATE OR REPLACE FUNCTION _cdb_crankshaft_internal_version()
-RETURNS text AS $$
-  SELECT installed_version FROM pg_available_extensions where name='crankshaft' and pg_available_extensions IS NOT NULL;
-$$ language 'sql' STABLE STRICT;
--- Internal function.
--- Set the seeds of the RNGs (Random Number Generators)
--- used internally.
-CREATE OR REPLACE FUNCTION
-_cdb_random_seeds (seed_value INTEGER) RETURNS VOID
-AS $$
-  from crankshaft import random_seeds
-  random_seeds.set_random_seeds(seed_value)
-$$ LANGUAGE plpythonu;
-CREATE OR REPLACE FUNCTION
-    CDB_PyAggS(current_state Numeric[], current_row Numeric[]) 
-    returns NUMERIC[] as $$
-    BEGIN
-        if array_upper(current_state,1) is null  then
-            RAISE NOTICE 'setting state %',array_upper(current_row,1);
-            current_state[1] = array_upper(current_row,1);
-        end if;
-        return array_cat(current_state,current_row) ;
-    END
-    $$ LANGUAGE plpgsql;
-
--- Create aggregate if it did not exist
-DO $$
-BEGIN
-    IF NOT EXISTS (
-        SELECT *
-        FROM pg_catalog.pg_proc p
-            LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
-        WHERE n.nspname = 'cdb_crankshaft'
-            AND p.proname = 'cdb_pyagg'
-            AND p.proisagg)
-    THEN
-        CREATE AGGREGATE CDB_PyAgg(NUMERIC[]) (
-            SFUNC = CDB_PyAggS,
-            STYPE = Numeric[],
-            INITCOND = "{}"
-        );
-    END IF;
-END
-$$ LANGUAGE plpgsql;
-
-CREATE OR REPLACE FUNCTION
-  CDB_CreateAndPredictSegment(
-    target NUMERIC[],
-    features NUMERIC[],
-    target_features NUMERIC[],
-    target_ids NUMERIC[],
-    n_estimators INTEGER DEFAULT 1200,
-    max_depth INTEGER DEFAULT 3,
-    subsample DOUBLE PRECISION DEFAULT 0.5,
-    learning_rate DOUBLE PRECISION DEFAULT 0.01,
-    min_samples_leaf INTEGER DEFAULT 1)
-RETURNS TABLE(cartodb_id NUMERIC, prediction NUMERIC, accuracy NUMERIC)
-AS $$
-    import numpy as np
-    import plpy
-
-    from crankshaft.segmentation import create_and_predict_segment_agg
-    model_params = {'n_estimators': n_estimators,
-                    'max_depth': max_depth,
-                    'subsample': subsample,
-                    'learning_rate': learning_rate,
-                    'min_samples_leaf': min_samples_leaf}
-
-    def unpack2D(data):
-        dimension = data.pop(0)
-        a = np.array(data, dtype=float)
-        return a.reshape(len(a)/dimension, dimension)
-
-    return create_and_predict_segment_agg(np.array(target, dtype=float),
-            unpack2D(features),
-            unpack2D(target_features),
-            target_ids,
-            model_params)
-
-$$ LANGUAGE plpythonu;
-
-CREATE OR REPLACE FUNCTION
-  CDB_CreateAndPredictSegment (
-      query TEXT,
-      variable_name TEXT,
-      target_table TEXT,
-      n_estimators INTEGER DEFAULT 1200,
-      max_depth INTEGER DEFAULT 3,
-      subsample DOUBLE PRECISION DEFAULT 0.5,
-      learning_rate DOUBLE PRECISION DEFAULT 0.01,
-      min_samples_leaf INTEGER DEFAULT 1)
-RETURNS TABLE (cartodb_id TEXT, prediction NUMERIC, accuracy NUMERIC)
-AS $$
-  from crankshaft.segmentation import create_and_predict_segment
-  model_params = {'n_estimators': n_estimators, 'max_depth':max_depth, 'subsample' : subsample, 'learning_rate': learning_rate, 'min_samples_leaf' : min_samples_leaf}
-  return create_and_predict_segment(query,variable_name,target_table, model_params)
-$$ LANGUAGE plpythonu;
-CREATE OR REPLACE FUNCTION CDB_Gravity(
-    IN target_query text,
-    IN weight_column text,
-    IN source_query text,
-    IN pop_column text,
-    IN target bigint,
-    IN radius integer,
-    IN minval numeric DEFAULT -10e307
-    )
-RETURNS TABLE(
-    the_geom geometry,
-    source_id bigint,
-    target_id bigint,
-    dist numeric,
-    h numeric,
-    hpop numeric)  AS $$
-DECLARE
-    t_id bigint[];
-    t_geom geometry[];
-    t_weight numeric[];
-    s_id bigint[];
-    s_geom geometry[];
-    s_pop numeric[];
-BEGIN
-    EXECUTE 'WITH foo as('+target_query+') SELECT array_agg(cartodb_id), array_agg(the_geom), array_agg(' || weight_column || ') FROM foo' INTO t_id, t_geom, t_weight;
-    EXECUTE 'WITH foo as('+source_query+') SELECT array_agg(cartodb_id), array_agg(the_geom), array_agg(' || pop_column || ') FROM foo' INTO s_id, s_geom, s_pop;
-    RETURN QUERY
-    SELECT g.* FROM t, s, CDB_Gravity(t_id, t_geom, t_weight, s_id, s_geom, s_pop, target, radius, minval) g;
-END;
-$$ language plpgsql;
-
-CREATE OR REPLACE FUNCTION CDB_Gravity(
-    IN t_id bigint[],
-    IN t_geom geometry[],
-    IN t_weight numeric[],
-    IN s_id bigint[],
-    IN s_geom geometry[],
-    IN s_pop numeric[],
-    IN target bigint,
-    IN radius integer,
-    IN minval numeric DEFAULT -10e307
-    )
-RETURNS TABLE(
-    the_geom geometry,
-    source_id bigint,
-    target_id bigint,
-    dist numeric,
-    h numeric,
-    hpop numeric)  AS $$
-DECLARE
-    t_type text;
-    s_type text;
-    t_center geometry[];
-    s_center geometry[];
-BEGIN
-    t_type := GeometryType(t_geom[1]);
-    s_type := GeometryType(s_geom[1]);
-    IF t_type = 'POINT' THEN
-        t_center := t_geom;
-    ELSE
-        WITH tmp as (SELECT unnest(t_geom) as g) SELECT array_agg(ST_Centroid(g)) INTO t_center FROM tmp;
-    END IF;
-    IF s_type = 'POINT' THEN
-        s_center := s_geom;
-    ELSE
-        WITH tmp as (SELECT unnest(s_geom) as g) SELECT array_agg(ST_Centroid(g)) INTO s_center FROM tmp;
-    END IF;
-    RETURN QUERY
-        with target0 as(
-            SELECT unnest(t_center) as tc, unnest(t_weight) as tw, unnest(t_id) as td
-        ),
-        source0 as(
-            SELECT unnest(s_center) as sc, unnest(s_id) as sd, unnest (s_geom) as sg, unnest(s_pop) as sp
-        ),
-        prev0 as(
-            SELECT
-                source0.sg,
-                source0.sd as sourc_id,
-                coalesce(source0.sp,0) as sp,
-                target.td as targ_id,
-                coalesce(target.tw,0) as tw,
-                GREATEST(1.0,ST_Distance(geography(target.tc), geography(source0.sc)))::numeric as distance
-            FROM source0
-            CROSS JOIN LATERAL
-                (
-                SELECT
-                    *
-                FROM target0
-                    WHERE tw > minval
-                    AND ST_DWithin(geography(source0.sc), geography(tc), radius)
-                ) AS target
-        ),
-        deno as(
-            SELECT
-                sourc_id,
-                sum(tw/distance) as h_deno
-            FROM
-                prev0
-            GROUP BY sourc_id
-        )
-        SELECT
-            p.sg as the_geom,
-            p.sourc_id as source_id,
-            p.targ_id as target_id,
-            case when p.distance > 1 then p.distance else 0.0 end as dist,
-            100*(p.tw/p.distance)/d.h_deno as h,
-            p.sp*(p.tw/p.distance)/d.h_deno as hpop
-        FROM
-            prev0 p,
-            deno d
-        WHERE
-            p.targ_id = target AND
-            p.sourc_id = d.sourc_id;
-END;
-$$ language plpgsql;
--- 0: nearest neighbor
--- 1: barymetric
--- 2: IDW
-
-CREATE OR REPLACE FUNCTION CDB_SpatialInterpolation(
-    IN query text,
-    IN point geometry,
-    IN method integer DEFAULT 1,
-    IN p1 numeric DEFAULT 0,
-    IN p2 numeric DEFAULT 0
-    )
-RETURNS numeric AS
-$$
-DECLARE
-    gs geometry[];
-    vs numeric[];
-    output numeric;
-BEGIN
-    EXECUTE 'WITH a AS('||query||') SELECT array_agg(the_geom), array_agg(attrib) FROM a' INTO gs, vs;
-    SELECT CDB_SpatialInterpolation(gs, vs, point, method, p1,p2) INTO output FROM a;
-
-    RETURN output;
-END;
-$$
-language plpgsql IMMUTABLE;
-
-CREATE OR REPLACE FUNCTION CDB_SpatialInterpolation(
-    IN geomin geometry[],
-    IN colin numeric[],
-    IN point geometry,
-    IN method integer DEFAULT 1,
-    IN p1 numeric DEFAULT 0,
-    IN p2 numeric DEFAULT 0
-    )
-RETURNS numeric AS
-$$
-DECLARE
-    gs geometry[];
-    vs numeric[];
-    gs2 geometry[];
-    vs2 numeric[];
-    g geometry;
-    vertex geometry[];
-    sg numeric;
-    sa numeric;
-    sb numeric;
-    sc numeric;
-    va numeric;
-    vb numeric;
-    vc numeric;
-    output numeric;
-BEGIN
-    output :=  -999.999;
-    -- nearest
-    IF method = 0 THEN
-
-        WITH    a as (SELECT unnest(geomin) as g, unnest(colin) as v)
-        SELECT a.v INTO output FROM a ORDER BY point<->a.g LIMIT 1;
-        RETURN output;
-
-    -- barymetric
-    ELSIF method = 1 THEN
-        WITH    a as (SELECT unnest(geomin) AS e),
-                b as (SELECT ST_DelaunayTriangles(ST_Collect(a.e),0.001, 0) AS t FROM a),
-                c as (SELECT (ST_Dump(t)).geom as v FROM b),
-                d as (SELECT v FROM c WHERE ST_Within(point, v))
-            SELECT v INTO g FROM d;
-        IF g is null THEN
-            -- out of the realm of the input data
-            RETURN -888.888;
-        END IF;
-        -- vertex of the selected cell
-        WITH a AS (SELECT (ST_DumpPoints(g)).geom AS v)
-                SELECT array_agg(v) INTO vertex FROM a;
-
-            -- retrieve the value of each vertex
-        WITH a AS(SELECT unnest(vertex) as geo, unnest(colin) as c)
-            SELECT c INTO va FROM a WHERE ST_Equals(geo, vertex[1]);
-        WITH a AS(SELECT unnest(vertex) as geo, unnest(colin) as c)
-            SELECT c INTO vb FROM a WHERE ST_Equals(geo, vertex[2]);
-        WITH a AS(SELECT unnest(vertex) as geo, unnest(colin) as c)
-                SELECT c INTO vc FROM a WHERE ST_Equals(geo, vertex[3]);
-
-        SELECT ST_area(g), ST_area(ST_MakePolygon(ST_MakeLine(ARRAY[point, vertex[2], vertex[3], point]))), ST_area(ST_MakePolygon(ST_MakeLine(ARRAY[point, vertex[1], vertex[3], point]))), ST_area(ST_MakePolygon(ST_MakeLine(ARRAY[point,vertex[1],vertex[2], point]))) INTO sg, sa, sb, sc;
-
-        output := (coalesce(sa,0) * coalesce(va,0) + coalesce(sb,0) * coalesce(vb,0) + coalesce(sc,0) * coalesce(vc,0)) / coalesce(sg);
-        RETURN output;
-
-    -- IDW
-    -- p1: limit the number of neighbors, 0->no limit
-    -- p2: order of distance decay, 0-> order 1
-    ELSIF method = 2 THEN
-
-        IF p2 = 0 THEN
-            p2 := 1;
-        END IF;
-
-        WITH    a as (SELECT unnest(geomin) as g, unnest(colin) as v),
-                b as (SELECT a.g, a.v FROM a ORDER BY point<->a.g)
-        SELECT array_agg(b.g), array_agg(b.v) INTO gs, vs FROM b;
-        IF p1::integer>0 THEN
-            gs2:=gs;
-            vs2:=vs;
-            FOR i IN 1..p1
-            LOOP
-                gs2 := gs2 || gs[i];
-                vs2 := vs2 || vs[i];
-            END LOOP;
-        ELSE
-            gs2:=gs;
-            vs2:=vs;
-        END IF;
-
-        WITH    a as (SELECT unnest(gs2) as g, unnest(vs2) as v),
-                b as (
-                    SELECT
-                    (1/ST_distance(point, a.g)^p2::integer) as k,
-                    (a.v/ST_distance(point, a.g)^p2::integer) as f
-                    FROM a
-                )
-        SELECT sum(b.f)/sum(b.k) INTO output FROM b;
-        RETURN output;
-
-    END IF;
-
-    RETURN -777.777;
-
-END;
-$$
-language plpgsql IMMUTABLE;
--- Moran's I Global Measure (public-facing)
-CREATE OR REPLACE FUNCTION
-  CDB_AreasOfInterestGlobal(
-      subquery TEXT,
-      column_name TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS TABLE (moran NUMERIC, significance NUMERIC)
-AS $$
-  from crankshaft.clustering import moran_local
-  # TODO: use named parameters or a dictionary
-  return moran(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
--- Moran's I Local (internal function)
-CREATE OR REPLACE FUNCTION
-  _CDB_AreasOfInterestLocal(
-      subquery TEXT,
-      column_name TEXT,
-      w_type TEXT,
-      num_ngbrs INT,
-      permutations INT,
-      geom_col TEXT,
-      id_col TEXT)
-RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-  from crankshaft.clustering import moran_local
-  # TODO: use named parameters or a dictionary
-  return moran_local(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
--- Moran's I Local (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_AreasOfInterestLocal(
-    subquery TEXT,
-    column_name TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col);
-
-$$ LANGUAGE SQL;
-
--- Moran's I only for HH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialHotspots(
-    subquery TEXT,
-    column_name TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HH', 'HL');
-
-$$ LANGUAGE SQL;
-
--- Moran's I only for LL and LH (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialColdspots(
-    subquery TEXT,
-    attr TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, attr, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('LL', 'LH');
-
-$$ LANGUAGE SQL;
-
--- Moran's I only for LH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialOutliers(
-    subquery TEXT,
-    attr TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, attr, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HL', 'LH');
-
-$$ LANGUAGE SQL;
-
--- Moran's I Global Rate (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_AreasOfInterestGlobalRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS TABLE (moran FLOAT, significance FLOAT)
-AS $$
-  from crankshaft.clustering import moran_local
-  # TODO: use named parameters or a dictionary
-  return moran_rate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
-
--- Moran's I Local Rate (internal function)
-CREATE OR REPLACE FUNCTION
-  _CDB_AreasOfInterestLocalRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT,
-      num_ngbrs INT,
-      permutations INT,
-      geom_col TEXT,
-      id_col TEXT)
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-  from crankshaft.clustering import moran_local_rate
-  # TODO: use named parameters or a dictionary
-  return moran_local_rate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
--- Moran's I Local Rate (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_AreasOfInterestLocalRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col);
-
-$$ LANGUAGE SQL;
-
--- Moran's I Local Rate only for HH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialHotspotsRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HH', 'HL');
-
-$$ LANGUAGE SQL;
-
--- Moran's I Local Rate only for LL and LH (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialColdspotsRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('LL', 'LH');
-
-$$ LANGUAGE SQL;
-
--- Moran's I Local Rate only for LH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialOutliersRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HL', 'LH');
-
-$$ LANGUAGE SQL;
-CREATE OR REPLACE FUNCTION  CDB_KMeans(query text, no_clusters integer,no_init integer default 20)
-RETURNS table (cartodb_id integer, cluster_no integer) as $$
-    
-    from crankshaft.clustering import kmeans
-    return kmeans(query,no_clusters,no_init)
-
-$$ language plpythonu;
-
-
-CREATE OR REPLACE FUNCTION CDB_WeightedMeanS(state Numeric[],the_geom GEOMETRY(Point, 4326), weight NUMERIC)
-RETURNS Numeric[] AS 
-$$
-DECLARE 
-    newX NUMERIC;
-    newY NUMERIC;
-    newW NUMERIC;
-BEGIN
-    IF weight IS NULL OR the_geom IS NULL THEN 
-        newX = state[1];
-        newY = state[2];
-        newW = state[3];
-    ELSE
-        newX = state[1] + ST_X(the_geom)*weight;
-        newY = state[2] + ST_Y(the_geom)*weight;
-        newW = state[3] + weight;
-    END IF;
-    RETURN Array[newX,newY,newW];
-
-END
-$$ LANGUAGE plpgsql;
-
-CREATE OR REPLACE FUNCTION CDB_WeightedMeanF(state Numeric[])
-RETURNS GEOMETRY AS 
-$$
-BEGIN
-    IF state[3] = 0 THEN 
-        RETURN ST_SetSRID(ST_MakePoint(state[1],state[2]), 4326);
-    ELSE 
-        RETURN ST_SETSRID(ST_MakePoint(state[1]/state[3], state[2]/state[3]),4326);
-    END IF;
-END
-$$ LANGUAGE plpgsql;
-
--- Create aggregate if it did not exist
-DO $$
-BEGIN
-    IF NOT EXISTS (
-        SELECT *
-        FROM pg_catalog.pg_proc p
-            LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
-        WHERE n.nspname = 'cdb_crankshaft'
-            AND p.proname = 'cdb_weightedmean'
-            AND p.proisagg)
-    THEN
-        CREATE AGGREGATE CDB_WeightedMean(geometry(Point, 4326), NUMERIC) (
-            SFUNC = CDB_WeightedMeanS,
-            FINALFUNC = CDB_WeightedMeanF,
-            STYPE = Numeric[],
-            INITCOND = "{0.0,0.0,0.0}" 
-        );
-    END IF;
-END
-$$ LANGUAGE plpgsql;
--- Spatial Markov
-
--- input table format:
--- id | geom | date_1 | date_2 | date_3
---  1 | Pt1  | 12.3   | 13.1   | 14.2
---  2 | Pt2  | 11.0   | 13.2   | 12.5
---  ...
--- Sample Function call:
--- SELECT CDB_SpatialMarkov('SELECT * FROM real_estate',
---                          Array['date_1', 'date_2', 'date_3'])
-
-CREATE OR REPLACE FUNCTION
-  CDB_SpatialMarkovTrend (
-      subquery TEXT,
-      time_cols TEXT[],
-      num_classes INT DEFAULT 7,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-  	  permutations INT DEFAULT 99,
-  	  geom_col TEXT DEFAULT 'the_geom',
-  	  id_col TEXT DEFAULT 'cartodb_id')
-RETURNS TABLE (trend NUMERIC, trend_up NUMERIC, trend_down NUMERIC, volatility NUMERIC, rowid INT)
-AS $$
-
-  from crankshaft.space_time_dynamics import spatial_markov_trend
-
-  ## TODO: use named parameters or a dictionary
-  return spatial_markov_trend(subquery, time_cols, num_classes, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
--- input table format: identical to above but in a predictable format
--- Sample function call:
--- SELECT cdb_spatial_markov('SELECT * FROM real_estate',
---                           'date_1')
-
-
--- CREATE OR REPLACE FUNCTION
---   cdb_spatial_markov (
---       subquery TEXT,
---       time_col_min text,
---       time_col_max text,
---       date_format text, -- '_YYYY_MM_DD'
---       num_time_per_bin INT DEFAULT 1,
---   	  permutations INT DEFAULT 99,
---   	  geom_column TEXT DEFAULT 'the_geom',
---   	  id_col TEXT DEFAULT 'cartodb_id',
---       w_type TEXT DEFAULT 'knn',
---       num_ngbrs int DEFAULT 5)
--- RETURNS TABLE (moran FLOAT, quads TEXT, significance FLOAT, ids INT)
--- AS $$
---   plpy.execute('SELECT cdb_crankshaft._cdb_crankshaft_activate_py()')
---   from crankshaft.clustering import moran_local
---   # TODO: use named parameters or a dictionary
---   return spatial_markov(subquery, time_cols, permutations, geom_column, id_col, w_type, num_ngbrs)
--- $$ LANGUAGE plpythonu;
---
--- -- input table format:
--- -- id | geom | date  | measurement
--- --  1 | Pt1  | 12/3  | 13.2
--- --  2 | Pt2  | 11/5  | 11.3
--- --  3 | Pt1  | 11/13 | 12.9
--- --  4 | Pt3  | 12/19 | 10.1
--- -- ...
---
--- CREATE OR REPLACE FUNCTION
---   cdb_spatial_markov (
---       subquery TEXT,
---       time_col text,
---       num_time_per_bin INT DEFAULT 1,
---   	  permutations INT DEFAULT 99,
---   	  geom_column TEXT DEFAULT 'the_geom',
---   	  id_col TEXT DEFAULT 'cartodb_id',
---       w_type TEXT DEFAULT 'knn',
---       num_ngbrs int DEFAULT 5)
--- RETURNS TABLE (moran FLOAT, quads TEXT, significance FLOAT, ids INT)
--- AS $$
---   plpy.execute('SELECT cdb_crankshaft._cdb_crankshaft_activate_py()')
---   from crankshaft.clustering import moran_local
---   # TODO: use named parameters or a dictionary
---   return spatial_markov(subquery, time_cols, permutations, geom_column, id_col, w_type, num_ngbrs)
--- $$ LANGUAGE plpythonu;
--- Function by Stuart Lynn for a simple interpolation of a value
--- from a polygon table over an arbitrary polygon
--- (weighted by the area proportion overlapped)
--- Aereal weighting is a very simple form of aereal interpolation.
---
--- Parameters:
---   * geom a Polygon geometry which defines the area where a value will be
---     estimated as the area-weighted sum of a given table/column
---   * target_table_name table name of the table that provides the values
---   * target_column column name of the column that provides the values
---   * schema_name optional parameter to defina the schema the target table
---     belongs to, which is necessary if its not in the search_path.
---     Note that target_table_name should never include the schema in it.
--- Return value:
---   Aereal-weighted interpolation of the column values over the geometry
-CREATE OR REPLACE
-FUNCTION cdb_overlap_sum(geom geometry, target_table_name text, target_column text, schema_name text DEFAULT NULL)
-  RETURNS numeric AS
-$$
-DECLARE
-	result numeric;
-  qualified_name text;
-BEGIN
-  IF schema_name IS NULL THEN
-    qualified_name := Format('%I', target_table_name);
-  ELSE
-    qualified_name := Format('%I.%s', schema_name, target_table_name);
-  END IF;
-  EXECUTE Format('
-    SELECT sum(%I*ST_Area(St_Intersection($1, a.the_geom))/ST_Area(a.the_geom))
-    FROM %s AS a
-    WHERE $1 && a.the_geom
-  ', target_column, qualified_name)
-  USING geom
-  INTO result;
-  RETURN result;
-END;
-$$ LANGUAGE plpgsql;
---
--- Creates N points randomly distributed arround the polygon
---
--- @param g - the geometry to be turned in to points
---
--- @param no_points - the number of points to generate
---
--- @params max_iter_per_point - the function generates points in the polygon's bounding box
--- and discards points which don't lie in the polygon. max_iter_per_point specifies how many
--- misses per point the funciton accepts before giving up.
---
--- Returns: Multipoint with the requested points
-CREATE OR REPLACE FUNCTION cdb_dot_density(geom geometry , no_points Integer, max_iter_per_point Integer DEFAULT 1000)
-RETURNS GEOMETRY AS $$
-DECLARE
-  extent GEOMETRY;
-  test_point Geometry;
-  width                NUMERIC;
-  height               NUMERIC;
-  x0                   NUMERIC;
-  y0                   NUMERIC;
-  xp                   NUMERIC;
-  yp                   NUMERIC;
-  no_left              INTEGER;
-  remaining_iterations INTEGER;
-  points               GEOMETRY[];
-  bbox_line            GEOMETRY;
-  intersection_line    GEOMETRY;
-BEGIN
-  extent  := ST_Envelope(geom);
-  width   := ST_XMax(extent) - ST_XMIN(extent);
-  height  := ST_YMax(extent) - ST_YMIN(extent);
-  x0 	  := ST_XMin(extent);
-  y0 	  := ST_YMin(extent);
-  no_left := no_points;
-
-  LOOP
-    if(no_left=0) THEN
-      EXIT;
-    END IF;
-    yp = y0 + height*random();
-    bbox_line  = ST_MakeLine(
-      ST_SetSRID(ST_MakePoint(yp, x0),4326),
-      ST_SetSRID(ST_MakePoint(yp, x0+width),4326)
-    );
-    intersection_line = ST_Intersection(bbox_line,geom);
-  	test_point = ST_LineInterpolatePoint(st_makeline(st_linemerge(intersection_line)),random());
-	  points := points || test_point;
-	  no_left = no_left - 1 ;
-  END LOOP;
-  RETURN ST_Collect(points);
-END;
-$$
-LANGUAGE plpgsql VOLATILE;
--- Make sure by default there are no permissions for publicuser
--- NOTE: this happens at extension creation time, as part of an implicit transaction.
--- REVOKE ALL PRIVILEGES ON SCHEMA cdb_crankshaft FROM PUBLIC, publicuser CASCADE;
-
--- Grant permissions on the schema to publicuser (but just the schema)
-GRANT USAGE ON SCHEMA cdb_crankshaft TO publicuser;
-
--- Revoke execute permissions on all functions in the schema by default
--- REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_crankshaft FROM PUBLIC, publicuser;

release/crankshaft--0.1.0.sql

@@ -1,686 +0,0 @@
---DO NOT MODIFY THIS FILE, IT IS GENERATED AUTOMATICALLY FROM SOURCES
--- Complain if script is sourced in psql, rather than via CREATE EXTENSION
-\echo Use "CREATE EXTENSION crankshaft" to load this file. \quit
--- Version number of the extension release
-CREATE OR REPLACE FUNCTION cdb_crankshaft_version()
-RETURNS text AS $$
-  SELECT '0.1.0'::text;
-$$ language 'sql' STABLE STRICT;
-
--- Internal identifier of the installed extension instence
--- e.g. 'dev' for current development version
-CREATE OR REPLACE FUNCTION _cdb_crankshaft_internal_version()
-RETURNS text AS $$
-  SELECT installed_version FROM pg_available_extensions where name='crankshaft' and pg_available_extensions IS NOT NULL;
-$$ language 'sql' STABLE STRICT;
--- Internal function.
--- Set the seeds of the RNGs (Random Number Generators)
--- used internally.
-CREATE OR REPLACE FUNCTION
-_cdb_random_seeds (seed_value INTEGER) RETURNS VOID
-AS $$
-  from crankshaft import random_seeds
-  random_seeds.set_random_seeds(seed_value)
-$$ LANGUAGE plpythonu;
-CREATE OR REPLACE FUNCTION
-    CDB_PyAggS(current_state Numeric[], current_row Numeric[]) 
-    returns NUMERIC[] as $$
-    BEGIN
-        if array_upper(current_state,1) is null  then
-            RAISE NOTICE 'setting state %',array_upper(current_row,1);
-            current_state[1] = array_upper(current_row,1);
-        end if;
-        return array_cat(current_state,current_row) ;
-    END
-    $$ LANGUAGE plpgsql;
-
-
-CREATE AGGREGATE CDB_PyAgg(NUMERIC[])(
-    SFUNC = CDB_PyAggS,
-    STYPE = Numeric[],
-    INITCOND = "{}" 
-);
-
-
-CREATE OR REPLACE FUNCTION
-  CDB_CreateAndPredictSegment(
-    target NUMERIC[],
-    features NUMERIC[],
-    target_features NUMERIC[],
-    target_ids NUMERIC[],
-    n_estimators INTEGER DEFAULT 1200,
-    max_depth INTEGER DEFAULT 3,
-    subsample DOUBLE PRECISION DEFAULT 0.5,
-    learning_rate DOUBLE PRECISION DEFAULT 0.01,
-    min_samples_leaf INTEGER DEFAULT 1)
-RETURNS TABLE(cartodb_id NUMERIC, prediction NUMERIC, accuracy NUMERIC)
-AS $$
-    import numpy as np
-    import plpy
-
-    from crankshaft.segmentation import create_and_predict_segment_agg
-    model_params = {'n_estimators': n_estimators,
-                    'max_depth': max_depth,
-                    'subsample': subsample,
-                    'learning_rate': learning_rate,
-                    'min_samples_leaf': min_samples_leaf}
-
-    def unpack2D(data):
-        dimension = data.pop(0)
-        a = np.array(data, dtype=float)
-        return a.reshape(len(a)/dimension, dimension)
-
-    return create_and_predict_segment_agg(np.array(target, dtype=float),
-            unpack2D(features),
-            unpack2D(target_features),
-            target_ids,
-            model_params)
-
-$$ LANGUAGE plpythonu;
-
-CREATE OR REPLACE FUNCTION
-  CDB_CreateAndPredictSegment (
-      query TEXT,
-      variable_name TEXT,
-      target_table TEXT,
-      n_estimators INTEGER DEFAULT 1200,
-      max_depth INTEGER DEFAULT 3,
-      subsample DOUBLE PRECISION DEFAULT 0.5,
-      learning_rate DOUBLE PRECISION DEFAULT 0.01,
-      min_samples_leaf INTEGER DEFAULT 1)
-RETURNS TABLE (cartodb_id TEXT, prediction NUMERIC, accuracy NUMERIC)
-AS $$
-  from crankshaft.segmentation import create_and_predict_segment
-  model_params = {'n_estimators': n_estimators, 'max_depth':max_depth, 'subsample' : subsample, 'learning_rate': learning_rate, 'min_samples_leaf' : min_samples_leaf}
-  return create_and_predict_segment(query,variable_name,target_table, model_params)
-$$ LANGUAGE plpythonu;
--- 0: nearest neighbor
--- 1: barymetric
--- 2: IDW
-
-CREATE OR REPLACE FUNCTION CDB_SpatialInterpolation(
-    IN query text,
-    IN point geometry,
-    IN method integer DEFAULT 1,
-    IN p1 numeric DEFAULT 0,
-    IN p2 numeric DEFAULT 0
-    )
-RETURNS numeric AS
-$$
-DECLARE
-    gs geometry[];
-    vs numeric[];
-    output numeric;
-BEGIN
-    EXECUTE 'WITH a AS('||query||') SELECT array_agg(the_geom), array_agg(attrib) FROM a' INTO gs, vs;
-    SELECT CDB_SpatialInterpolation(gs, vs, point, method, p1,p2) INTO output FROM a;
-
-    RETURN output;
-END;
-$$
-language plpgsql IMMUTABLE;
-
-CREATE OR REPLACE FUNCTION CDB_SpatialInterpolation(
-    IN geomin geometry[],
-    IN colin numeric[],
-    IN point geometry,
-    IN method integer DEFAULT 1,
-    IN p1 numeric DEFAULT 0,
-    IN p2 numeric DEFAULT 0
-    )
-RETURNS numeric AS
-$$
-DECLARE
-    gs geometry[];
-    vs numeric[];
-    gs2 geometry[];
-    vs2 numeric[];
-    g geometry;
-    vertex geometry[];
-    sg numeric;
-    sa numeric;
-    sb numeric;
-    sc numeric;
-    va numeric;
-    vb numeric;
-    vc numeric;
-    output numeric;
-BEGIN
-    output :=  -999.999;
-    -- nearest
-    IF method = 0 THEN
-
-        WITH    a as (SELECT unnest(geomin) as g, unnest(colin) as v)
-        SELECT a.v INTO output FROM a ORDER BY point<->a.g LIMIT 1;
-        RETURN output;
-
-    -- barymetric
-    ELSIF method = 1 THEN
-        WITH    a as (SELECT unnest(geomin) AS e),
-                b as (SELECT ST_DelaunayTriangles(ST_Collect(a.e),0.001, 0) AS t FROM a),
-                c as (SELECT (ST_Dump(t)).geom as v FROM b),
-                d as (SELECT v FROM c WHERE ST_Within(point, v))
-            SELECT v INTO g FROM d;
-        IF g is null THEN
-            -- out of the realm of the input data
-            RETURN -888.888;
-        END IF;
-        -- vertex of the selected cell
-        WITH a AS (SELECT (ST_DumpPoints(g)).geom AS v)
-                SELECT array_agg(v) INTO vertex FROM a;
-
-            -- retrieve the value of each vertex
-        WITH a AS(SELECT unnest(vertex) as geo, unnest(colin) as c)
-            SELECT c INTO va FROM a WHERE ST_Equals(geo, vertex[1]);
-        WITH a AS(SELECT unnest(vertex) as geo, unnest(colin) as c)
-            SELECT c INTO vb FROM a WHERE ST_Equals(geo, vertex[2]);
-        WITH a AS(SELECT unnest(vertex) as geo, unnest(colin) as c)
-                SELECT c INTO vc FROM a WHERE ST_Equals(geo, vertex[3]);
-
-        SELECT ST_area(g), ST_area(ST_MakePolygon(ST_MakeLine(ARRAY[point, vertex[2], vertex[3], point]))), ST_area(ST_MakePolygon(ST_MakeLine(ARRAY[point, vertex[1], vertex[3], point]))), ST_area(ST_MakePolygon(ST_MakeLine(ARRAY[point,vertex[1],vertex[2], point]))) INTO sg, sa, sb, sc;
-
-        output := (coalesce(sa,0) * coalesce(va,0) + coalesce(sb,0) * coalesce(vb,0) + coalesce(sc,0) * coalesce(vc,0)) / coalesce(sg);
-        RETURN output;
-
-    -- IDW
-    -- p1: limit the number of neighbors, 0->no limit
-    -- p2: order of distance decay, 0-> order 1
-    ELSIF method = 2 THEN
-
-        IF p2 = 0 THEN
-            p2 := 1;
-        END IF;
-
-        WITH    a as (SELECT unnest(geomin) as g, unnest(colin) as v),
-                b as (SELECT a.g, a.v FROM a ORDER BY point<->a.g)
-        SELECT array_agg(b.g), array_agg(b.v) INTO gs, vs FROM b;
-        IF p1::integer>0 THEN
-            gs2:=gs;
-            vs2:=vs;
-            FOR i IN 1..p1
-            LOOP
-                gs2 := gs2 || gs[i];
-                vs2 := vs2 || vs[i];
-            END LOOP;
-        ELSE
-            gs2:=gs;
-            vs2:=vs;
-        END IF;
-
-        WITH    a as (SELECT unnest(gs2) as g, unnest(vs2) as v),
-                b as (
-                    SELECT
-                    (1/ST_distance(point, a.g)^p2::integer) as k,
-                    (a.v/ST_distance(point, a.g)^p2::integer) as f
-                    FROM a
-                )
-        SELECT sum(b.f)/sum(b.k) INTO output FROM b;
-        RETURN output;
-
-    END IF;
-
-    RETURN -777.777;
-
-END;
-$$
-language plpgsql IMMUTABLE;
--- Moran's I Global Measure (public-facing)
-CREATE OR REPLACE FUNCTION
-  CDB_AreasOfInterestGlobal(
-      subquery TEXT,
-      column_name TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS TABLE (moran NUMERIC, significance NUMERIC)
-AS $$
-  from crankshaft.clustering import moran_local
-  # TODO: use named parameters or a dictionary
-  return moran(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
--- Moran's I Local (internal function)
-CREATE OR REPLACE FUNCTION
-  _CDB_AreasOfInterestLocal(
-      subquery TEXT,
-      column_name TEXT,
-      w_type TEXT,
-      num_ngbrs INT,
-      permutations INT,
-      geom_col TEXT,
-      id_col TEXT)
-RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-  from crankshaft.clustering import moran_local
-  # TODO: use named parameters or a dictionary
-  return moran_local(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
--- Moran's I Local (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_AreasOfInterestLocal(
-    subquery TEXT,
-    column_name TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col);
-
-$$ LANGUAGE SQL;
-
--- Moran's I only for HH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialHotspots(
-    subquery TEXT,
-    column_name TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HH', 'HL');
-
-$$ LANGUAGE SQL;
-
--- Moran's I only for LL and LH (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialColdspots(
-    subquery TEXT,
-    attr TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, attr, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('LL', 'LH');
-
-$$ LANGUAGE SQL;
-
--- Moran's I only for LH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialOutliers(
-    subquery TEXT,
-    attr TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, attr, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HL', 'LH');
-
-$$ LANGUAGE SQL;
-
--- Moran's I Global Rate (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_AreasOfInterestGlobalRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS TABLE (moran FLOAT, significance FLOAT)
-AS $$
-  from crankshaft.clustering import moran_local
-  # TODO: use named parameters or a dictionary
-  return moran_rate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
-
--- Moran's I Local Rate (internal function)
-CREATE OR REPLACE FUNCTION
-  _CDB_AreasOfInterestLocalRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT,
-      num_ngbrs INT,
-      permutations INT,
-      geom_col TEXT,
-      id_col TEXT)
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-  from crankshaft.clustering import moran_local_rate
-  # TODO: use named parameters or a dictionary
-  return moran_local_rate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
--- Moran's I Local Rate (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_AreasOfInterestLocalRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col);
-
-$$ LANGUAGE SQL;
-
--- Moran's I Local Rate only for HH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialHotspotsRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HH', 'HL');
-
-$$ LANGUAGE SQL;
-
--- Moran's I Local Rate only for LL and LH (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialColdspotsRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('LL', 'LH');
-
-$$ LANGUAGE SQL;
-
--- Moran's I Local Rate only for LH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialOutliersRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HL', 'LH');
-
-$$ LANGUAGE SQL;
-CREATE OR REPLACE FUNCTION  CDB_KMeans(query text, no_clusters integer,no_init integer default 20)
-RETURNS table (cartodb_id integer, cluster_no integer) as $$
-    
-    from crankshaft.clustering import kmeans
-    return kmeans(query,no_clusters,no_init)
-
-$$ language plpythonu;
-
-
-CREATE OR REPLACE FUNCTION CDB_WeightedMeanS(state Numeric[],the_geom GEOMETRY(Point, 4326), weight NUMERIC)
-RETURNS Numeric[] AS 
-$$
-DECLARE 
-    newX NUMERIC;
-    newY NUMERIC;
-    newW NUMERIC;
-BEGIN
-    IF weight IS NULL OR the_geom IS NULL THEN 
-        newX = state[1];
-        newY = state[2];
-        newW = state[3];
-    ELSE
-        newX = state[1] + ST_X(the_geom)*weight;
-        newY = state[2] + ST_Y(the_geom)*weight;
-        newW = state[3] + weight;
-    END IF;
-    RETURN Array[newX,newY,newW];
-
-END
-$$ LANGUAGE plpgsql;
-
-CREATE OR REPLACE FUNCTION CDB_WeightedMeanF(state Numeric[])
-RETURNS GEOMETRY AS 
-$$
-BEGIN
-    IF state[3] = 0 THEN 
-        RETURN ST_SetSRID(ST_MakePoint(state[1],state[2]), 4326);
-    ELSE 
-        RETURN ST_SETSRID(ST_MakePoint(state[1]/state[3], state[2]/state[3]),4326);
-    END IF;
-END
-$$ LANGUAGE plpgsql;
-
-CREATE AGGREGATE CDB_WeightedMean(geometry(Point, 4326), NUMERIC)(
-    SFUNC = CDB_WeightedMeanS,
-    FINALFUNC = CDB_WeightedMeanF,
-    STYPE = Numeric[],
-    INITCOND = "{0.0,0.0,0.0}" 
-);
--- Spatial Markov
-
--- input table format:
--- id | geom | date_1 | date_2 | date_3
---  1 | Pt1  | 12.3   | 13.1   | 14.2
---  2 | Pt2  | 11.0   | 13.2   | 12.5
---  ...
--- Sample Function call:
--- SELECT CDB_SpatialMarkov('SELECT * FROM real_estate',
---                          Array['date_1', 'date_2', 'date_3'])
-
-CREATE OR REPLACE FUNCTION
-  CDB_SpatialMarkovTrend (
-      subquery TEXT,
-      time_cols TEXT[],
-      num_classes INT DEFAULT 7,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-  	  permutations INT DEFAULT 99,
-  	  geom_col TEXT DEFAULT 'the_geom',
-  	  id_col TEXT DEFAULT 'cartodb_id')
-RETURNS TABLE (trend NUMERIC, trend_up NUMERIC, trend_down NUMERIC, volatility NUMERIC, rowid INT)
-AS $$
-
-  from crankshaft.space_time_dynamics import spatial_markov_trend
-
-  ## TODO: use named parameters or a dictionary
-  return spatial_markov_trend(subquery, time_cols, num_classes, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
--- input table format: identical to above but in a predictable format
--- Sample function call:
--- SELECT cdb_spatial_markov('SELECT * FROM real_estate',
---                           'date_1')
-
-
--- CREATE OR REPLACE FUNCTION
---   cdb_spatial_markov (
---       subquery TEXT,
---       time_col_min text,
---       time_col_max text,
---       date_format text, -- '_YYYY_MM_DD'
---       num_time_per_bin INT DEFAULT 1,
---   	  permutations INT DEFAULT 99,
---   	  geom_column TEXT DEFAULT 'the_geom',
---   	  id_col TEXT DEFAULT 'cartodb_id',
---       w_type TEXT DEFAULT 'knn',
---       num_ngbrs int DEFAULT 5)
--- RETURNS TABLE (moran FLOAT, quads TEXT, significance FLOAT, ids INT)
--- AS $$
---   plpy.execute('SELECT cdb_crankshaft._cdb_crankshaft_activate_py()')
---   from crankshaft.clustering import moran_local
---   # TODO: use named parameters or a dictionary
---   return spatial_markov(subquery, time_cols, permutations, geom_column, id_col, w_type, num_ngbrs)
--- $$ LANGUAGE plpythonu;
---
--- -- input table format:
--- -- id | geom | date  | measurement
--- --  1 | Pt1  | 12/3  | 13.2
--- --  2 | Pt2  | 11/5  | 11.3
--- --  3 | Pt1  | 11/13 | 12.9
--- --  4 | Pt3  | 12/19 | 10.1
--- -- ...
---
--- CREATE OR REPLACE FUNCTION
---   cdb_spatial_markov (
---       subquery TEXT,
---       time_col text,
---       num_time_per_bin INT DEFAULT 1,
---   	  permutations INT DEFAULT 99,
---   	  geom_column TEXT DEFAULT 'the_geom',
---   	  id_col TEXT DEFAULT 'cartodb_id',
---       w_type TEXT DEFAULT 'knn',
---       num_ngbrs int DEFAULT 5)
--- RETURNS TABLE (moran FLOAT, quads TEXT, significance FLOAT, ids INT)
--- AS $$
---   plpy.execute('SELECT cdb_crankshaft._cdb_crankshaft_activate_py()')
---   from crankshaft.clustering import moran_local
---   # TODO: use named parameters or a dictionary
---   return spatial_markov(subquery, time_cols, permutations, geom_column, id_col, w_type, num_ngbrs)
--- $$ LANGUAGE plpythonu;
--- Function by Stuart Lynn for a simple interpolation of a value
--- from a polygon table over an arbitrary polygon
--- (weighted by the area proportion overlapped)
--- Aereal weighting is a very simple form of aereal interpolation.
---
--- Parameters:
---   * geom a Polygon geometry which defines the area where a value will be
---     estimated as the area-weighted sum of a given table/column
---   * target_table_name table name of the table that provides the values
---   * target_column column name of the column that provides the values
---   * schema_name optional parameter to defina the schema the target table
---     belongs to, which is necessary if its not in the search_path.
---     Note that target_table_name should never include the schema in it.
--- Return value:
---   Aereal-weighted interpolation of the column values over the geometry
-CREATE OR REPLACE
-FUNCTION cdb_overlap_sum(geom geometry, target_table_name text, target_column text, schema_name text DEFAULT NULL)
-  RETURNS numeric AS
-$$
-DECLARE
-	result numeric;
-  qualified_name text;
-BEGIN
-  IF schema_name IS NULL THEN
-    qualified_name := Format('%I', target_table_name);
-  ELSE
-    qualified_name := Format('%I.%s', schema_name, target_table_name);
-  END IF;
-  EXECUTE Format('
-    SELECT sum(%I*ST_Area(St_Intersection($1, a.the_geom))/ST_Area(a.the_geom))
-    FROM %s AS a
-    WHERE $1 && a.the_geom
-  ', target_column, qualified_name)
-  USING geom
-  INTO result;
-  RETURN result;
-END;
-$$ LANGUAGE plpgsql;
---
--- Creates N points randomly distributed arround the polygon
---
--- @param g - the geometry to be turned in to points
---
--- @param no_points - the number of points to generate
---
--- @params max_iter_per_point - the function generates points in the polygon's bounding box
--- and discards points which don't lie in the polygon. max_iter_per_point specifies how many
--- misses per point the funciton accepts before giving up.
---
--- Returns: Multipoint with the requested points
-CREATE OR REPLACE FUNCTION cdb_dot_density(geom geometry , no_points Integer, max_iter_per_point Integer DEFAULT 1000)
-RETURNS GEOMETRY AS $$
-DECLARE
-  extent GEOMETRY;
-  test_point Geometry;
-  width                NUMERIC;
-  height               NUMERIC;
-  x0                   NUMERIC;
-  y0                   NUMERIC;
-  xp                   NUMERIC;
-  yp                   NUMERIC;
-  no_left              INTEGER;
-  remaining_iterations INTEGER;
-  points               GEOMETRY[];
-  bbox_line            GEOMETRY;
-  intersection_line    GEOMETRY;
-BEGIN
-  extent  := ST_Envelope(geom);
-  width   := ST_XMax(extent) - ST_XMIN(extent);
-  height  := ST_YMax(extent) - ST_YMIN(extent);
-  x0 	  := ST_XMin(extent);
-  y0 	  := ST_YMin(extent);
-  no_left := no_points;
-
-  LOOP
-    if(no_left=0) THEN
-      EXIT;
-    END IF;
-    yp = y0 + height*random();
-    bbox_line  = ST_MakeLine(
-      ST_SetSRID(ST_MakePoint(yp, x0),4326),
-      ST_SetSRID(ST_MakePoint(yp, x0+width),4326)
-    );
-    intersection_line = ST_Intersection(bbox_line,geom);
-  	test_point = ST_LineInterpolatePoint(st_makeline(st_linemerge(intersection_line)),random());
-	  points := points || test_point;
-	  no_left = no_left - 1 ;
-  END LOOP;
-  RETURN ST_Collect(points);
-END;
-$$
-LANGUAGE plpgsql VOLATILE;
--- Make sure by default there are no permissions for publicuser
--- NOTE: this happens at extension creation time, as part of an implicit transaction.
--- REVOKE ALL PRIVILEGES ON SCHEMA cdb_crankshaft FROM PUBLIC, publicuser CASCADE;
-
--- Grant permissions on the schema to publicuser (but just the schema)
-GRANT USAGE ON SCHEMA cdb_crankshaft TO publicuser;
-
--- Revoke execute permissions on all functions in the schema by default
--- REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_crankshaft FROM PUBLIC, publicuser;

release/crankshaft--0.2.0.sql

@@ -1,827 +0,0 @@
---DO NOT MODIFY THIS FILE, IT IS GENERATED AUTOMATICALLY FROM SOURCES
--- Complain if script is sourced in psql, rather than via CREATE EXTENSION
-\echo Use "CREATE EXTENSION crankshaft" to load this file. \quit
--- Version number of the extension release
-CREATE OR REPLACE FUNCTION cdb_crankshaft_version()
-RETURNS text AS $$
-  SELECT '0.2.0'::text;
-$$ language 'sql' STABLE STRICT;
-
--- Internal identifier of the installed extension instence
--- e.g. 'dev' for current development version
-CREATE OR REPLACE FUNCTION _cdb_crankshaft_internal_version()
-RETURNS text AS $$
-  SELECT installed_version FROM pg_available_extensions where name='crankshaft' and pg_available_extensions IS NOT NULL;
-$$ language 'sql' STABLE STRICT;
--- Internal function.
--- Set the seeds of the RNGs (Random Number Generators)
--- used internally.
-CREATE OR REPLACE FUNCTION
-_cdb_random_seeds (seed_value INTEGER) RETURNS VOID
-AS $$
-  from crankshaft import random_seeds
-  random_seeds.set_random_seeds(seed_value)
-$$ LANGUAGE plpythonu;
-CREATE OR REPLACE FUNCTION
-    CDB_PyAggS(current_state Numeric[], current_row Numeric[]) 
-    returns NUMERIC[] as $$
-    BEGIN
-        if array_upper(current_state,1) is null  then
-            RAISE NOTICE 'setting state %',array_upper(current_row,1);
-            current_state[1] = array_upper(current_row,1);
-        end if;
-        return array_cat(current_state,current_row) ;
-    END
-    $$ LANGUAGE plpgsql;
-
--- Create aggregate if it did not exist
-DO $$
-BEGIN
-    IF NOT EXISTS (
-        SELECT *
-        FROM pg_catalog.pg_proc p
-            LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
-        WHERE n.nspname = 'cdb_crankshaft'
-            AND p.proname = 'cdb_pyagg'
-            AND p.proisagg)
-    THEN
-        CREATE AGGREGATE CDB_PyAgg(NUMERIC[]) (
-            SFUNC = CDB_PyAggS,
-            STYPE = Numeric[],
-            INITCOND = "{}"
-        );
-    END IF;
-END
-$$ LANGUAGE plpgsql;
-
-CREATE OR REPLACE FUNCTION
-  CDB_CreateAndPredictSegment(
-    target NUMERIC[],
-    features NUMERIC[],
-    target_features NUMERIC[],
-    target_ids NUMERIC[],
-    n_estimators INTEGER DEFAULT 1200,
-    max_depth INTEGER DEFAULT 3,
-    subsample DOUBLE PRECISION DEFAULT 0.5,
-    learning_rate DOUBLE PRECISION DEFAULT 0.01,
-    min_samples_leaf INTEGER DEFAULT 1)
-RETURNS TABLE(cartodb_id NUMERIC, prediction NUMERIC, accuracy NUMERIC)
-AS $$
-    import numpy as np
-    import plpy
-
-    from crankshaft.segmentation import create_and_predict_segment_agg
-    model_params = {'n_estimators': n_estimators,
-                    'max_depth': max_depth,
-                    'subsample': subsample,
-                    'learning_rate': learning_rate,
-                    'min_samples_leaf': min_samples_leaf}
-
-    def unpack2D(data):
-        dimension = data.pop(0)
-        a = np.array(data, dtype=float)
-        return a.reshape(len(a)/dimension, dimension)
-
-    return create_and_predict_segment_agg(np.array(target, dtype=float),
-            unpack2D(features),
-            unpack2D(target_features),
-            target_ids,
-            model_params)
-
-$$ LANGUAGE plpythonu;
-
-CREATE OR REPLACE FUNCTION
-  CDB_CreateAndPredictSegment (
-      query TEXT,
-      variable_name TEXT,
-      target_table TEXT,
-      n_estimators INTEGER DEFAULT 1200,
-      max_depth INTEGER DEFAULT 3,
-      subsample DOUBLE PRECISION DEFAULT 0.5,
-      learning_rate DOUBLE PRECISION DEFAULT 0.01,
-      min_samples_leaf INTEGER DEFAULT 1)
-RETURNS TABLE (cartodb_id TEXT, prediction NUMERIC, accuracy NUMERIC)
-AS $$
-  from crankshaft.segmentation import create_and_predict_segment
-  model_params = {'n_estimators': n_estimators, 'max_depth':max_depth, 'subsample' : subsample, 'learning_rate': learning_rate, 'min_samples_leaf' : min_samples_leaf}
-  return create_and_predict_segment(query,variable_name,target_table, model_params)
-$$ LANGUAGE plpythonu;
-CREATE OR REPLACE FUNCTION CDB_Gravity(
-    IN target_query text,
-    IN weight_column text,
-    IN source_query text,
-    IN pop_column text,
-    IN target bigint,
-    IN radius integer,
-    IN minval numeric DEFAULT -10e307
-    )
-RETURNS TABLE(
-    the_geom geometry,
-    source_id bigint,
-    target_id bigint,
-    dist numeric,
-    h numeric,
-    hpop numeric)  AS $$
-DECLARE
-    t_id bigint[];
-    t_geom geometry[];
-    t_weight numeric[];
-    s_id bigint[];
-    s_geom geometry[];
-    s_pop numeric[];
-BEGIN
-    EXECUTE 'WITH foo as('+target_query+') SELECT array_agg(cartodb_id), array_agg(the_geom), array_agg(' || weight_column || ') FROM foo' INTO t_id, t_geom, t_weight;
-    EXECUTE 'WITH foo as('+source_query+') SELECT array_agg(cartodb_id), array_agg(the_geom), array_agg(' || pop_column || ') FROM foo' INTO s_id, s_geom, s_pop;
-    RETURN QUERY
-    SELECT g.* FROM t, s, CDB_Gravity(t_id, t_geom, t_weight, s_id, s_geom, s_pop, target, radius, minval) g;
-END;
-$$ language plpgsql;
-
-CREATE OR REPLACE FUNCTION CDB_Gravity(
-    IN t_id bigint[],
-    IN t_geom geometry[],
-    IN t_weight numeric[],
-    IN s_id bigint[],
-    IN s_geom geometry[],
-    IN s_pop numeric[],
-    IN target bigint,
-    IN radius integer,
-    IN minval numeric DEFAULT -10e307
-    )
-RETURNS TABLE(
-    the_geom geometry,
-    source_id bigint,
-    target_id bigint,
-    dist numeric,
-    h numeric,
-    hpop numeric)  AS $$
-DECLARE
-    t_type text;
-    s_type text;
-    t_center geometry[];
-    s_center geometry[];
-BEGIN
-    t_type := GeometryType(t_geom[1]);
-    s_type := GeometryType(s_geom[1]);
-    IF t_type = 'POINT' THEN
-        t_center := t_geom;
-    ELSE
-        WITH tmp as (SELECT unnest(t_geom) as g) SELECT array_agg(ST_Centroid(g)) INTO t_center FROM tmp;
-    END IF;
-    IF s_type = 'POINT' THEN
-        s_center := s_geom;
-    ELSE
-        WITH tmp as (SELECT unnest(s_geom) as g) SELECT array_agg(ST_Centroid(g)) INTO s_center FROM tmp;
-    END IF;
-    RETURN QUERY
-        with target0 as(
-            SELECT unnest(t_center) as tc, unnest(t_weight) as tw, unnest(t_id) as td
-        ),
-        source0 as(
-            SELECT unnest(s_center) as sc, unnest(s_id) as sd, unnest (s_geom) as sg, unnest(s_pop) as sp
-        ),
-        prev0 as(
-            SELECT
-                source0.sg,
-                source0.sd as sourc_id,
-                coalesce(source0.sp,0) as sp,
-                target.td as targ_id,
-                coalesce(target.tw,0) as tw,
-                GREATEST(1.0,ST_Distance(geography(target.tc), geography(source0.sc)))::numeric as distance
-            FROM source0
-            CROSS JOIN LATERAL
-                (
-                SELECT
-                    *
-                FROM target0
-                    WHERE tw > minval
-                    AND ST_DWithin(geography(source0.sc), geography(tc), radius)
-                ) AS target
-        ),
-        deno as(
-            SELECT
-                sourc_id,
-                sum(tw/distance) as h_deno
-            FROM
-                prev0
-            GROUP BY sourc_id
-        )
-        SELECT
-            p.sg as the_geom,
-            p.sourc_id as source_id,
-            p.targ_id as target_id,
-            case when p.distance > 1 then p.distance else 0.0 end as dist,
-            100*(p.tw/p.distance)/d.h_deno as h,
-            p.sp*(p.tw/p.distance)/d.h_deno as hpop
-        FROM
-            prev0 p,
-            deno d
-        WHERE
-            p.targ_id = target AND
-            p.sourc_id = d.sourc_id;
-END;
-$$ language plpgsql;
--- 0: nearest neighbor
--- 1: barymetric
--- 2: IDW
-
-CREATE OR REPLACE FUNCTION CDB_SpatialInterpolation(
-    IN query text,
-    IN point geometry,
-    IN method integer DEFAULT 1,
-    IN p1 numeric DEFAULT 0,
-    IN p2 numeric DEFAULT 0
-    )
-RETURNS numeric AS
-$$
-DECLARE
-    gs geometry[];
-    vs numeric[];
-    output numeric;
-BEGIN
-    EXECUTE 'WITH a AS('||query||') SELECT array_agg(the_geom), array_agg(attrib) FROM a' INTO gs, vs;
-    SELECT CDB_SpatialInterpolation(gs, vs, point, method, p1,p2) INTO output FROM a;
-
-    RETURN output;
-END;
-$$
-language plpgsql IMMUTABLE;
-
-CREATE OR REPLACE FUNCTION CDB_SpatialInterpolation(
-    IN geomin geometry[],
-    IN colin numeric[],
-    IN point geometry,
-    IN method integer DEFAULT 1,
-    IN p1 numeric DEFAULT 0,
-    IN p2 numeric DEFAULT 0
-    )
-RETURNS numeric AS
-$$
-DECLARE
-    gs geometry[];
-    vs numeric[];
-    gs2 geometry[];
-    vs2 numeric[];
-    g geometry;
-    vertex geometry[];
-    sg numeric;
-    sa numeric;
-    sb numeric;
-    sc numeric;
-    va numeric;
-    vb numeric;
-    vc numeric;
-    output numeric;
-BEGIN
-    output :=  -999.999;
-    -- nearest
-    IF method = 0 THEN
-
-        WITH    a as (SELECT unnest(geomin) as g, unnest(colin) as v)
-        SELECT a.v INTO output FROM a ORDER BY point<->a.g LIMIT 1;
-        RETURN output;
-
-    -- barymetric
-    ELSIF method = 1 THEN
-        WITH    a as (SELECT unnest(geomin) AS e),
-                b as (SELECT ST_DelaunayTriangles(ST_Collect(a.e),0.001, 0) AS t FROM a),
-                c as (SELECT (ST_Dump(t)).geom as v FROM b),
-                d as (SELECT v FROM c WHERE ST_Within(point, v))
-            SELECT v INTO g FROM d;
-        IF g is null THEN
-            -- out of the realm of the input data
-            RETURN -888.888;
-        END IF;
-        -- vertex of the selected cell
-        WITH a AS (SELECT (ST_DumpPoints(g)).geom AS v)
-                SELECT array_agg(v) INTO vertex FROM a;
-
-            -- retrieve the value of each vertex
-        WITH a AS(SELECT unnest(vertex) as geo, unnest(colin) as c)
-            SELECT c INTO va FROM a WHERE ST_Equals(geo, vertex[1]);
-        WITH a AS(SELECT unnest(vertex) as geo, unnest(colin) as c)
-            SELECT c INTO vb FROM a WHERE ST_Equals(geo, vertex[2]);
-        WITH a AS(SELECT unnest(vertex) as geo, unnest(colin) as c)
-                SELECT c INTO vc FROM a WHERE ST_Equals(geo, vertex[3]);
-
-        SELECT ST_area(g), ST_area(ST_MakePolygon(ST_MakeLine(ARRAY[point, vertex[2], vertex[3], point]))), ST_area(ST_MakePolygon(ST_MakeLine(ARRAY[point, vertex[1], vertex[3], point]))), ST_area(ST_MakePolygon(ST_MakeLine(ARRAY[point,vertex[1],vertex[2], point]))) INTO sg, sa, sb, sc;
-
-        output := (coalesce(sa,0) * coalesce(va,0) + coalesce(sb,0) * coalesce(vb,0) + coalesce(sc,0) * coalesce(vc,0)) / coalesce(sg);
-        RETURN output;
-
-    -- IDW
-    -- p1: limit the number of neighbors, 0->no limit
-    -- p2: order of distance decay, 0-> order 1
-    ELSIF method = 2 THEN
-
-        IF p2 = 0 THEN
-            p2 := 1;
-        END IF;
-
-        WITH    a as (SELECT unnest(geomin) as g, unnest(colin) as v),
-                b as (SELECT a.g, a.v FROM a ORDER BY point<->a.g)
-        SELECT array_agg(b.g), array_agg(b.v) INTO gs, vs FROM b;
-        IF p1::integer>0 THEN
-            gs2:=gs;
-            vs2:=vs;
-            FOR i IN 1..p1
-            LOOP
-                gs2 := gs2 || gs[i];
-                vs2 := vs2 || vs[i];
-            END LOOP;
-        ELSE
-            gs2:=gs;
-            vs2:=vs;
-        END IF;
-
-        WITH    a as (SELECT unnest(gs2) as g, unnest(vs2) as v),
-                b as (
-                    SELECT
-                    (1/ST_distance(point, a.g)^p2::integer) as k,
-                    (a.v/ST_distance(point, a.g)^p2::integer) as f
-                    FROM a
-                )
-        SELECT sum(b.f)/sum(b.k) INTO output FROM b;
-        RETURN output;
-
-    END IF;
-
-    RETURN -777.777;
-
-END;
-$$
-language plpgsql IMMUTABLE;
--- Moran's I Global Measure (public-facing)
-CREATE OR REPLACE FUNCTION
-  CDB_AreasOfInterestGlobal(
-      subquery TEXT,
-      column_name TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS TABLE (moran NUMERIC, significance NUMERIC)
-AS $$
-  from crankshaft.clustering import moran_local
-  # TODO: use named parameters or a dictionary
-  return moran(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
--- Moran's I Local (internal function)
-CREATE OR REPLACE FUNCTION
-  _CDB_AreasOfInterestLocal(
-      subquery TEXT,
-      column_name TEXT,
-      w_type TEXT,
-      num_ngbrs INT,
-      permutations INT,
-      geom_col TEXT,
-      id_col TEXT)
-RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-  from crankshaft.clustering import moran_local
-  # TODO: use named parameters or a dictionary
-  return moran_local(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
--- Moran's I Local (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_AreasOfInterestLocal(
-    subquery TEXT,
-    column_name TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col);
-
-$$ LANGUAGE SQL;
-
--- Moran's I only for HH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialHotspots(
-    subquery TEXT,
-    column_name TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, column_name, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HH', 'HL');
-
-$$ LANGUAGE SQL;
-
--- Moran's I only for LL and LH (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialColdspots(
-    subquery TEXT,
-    attr TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, attr, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('LL', 'LH');
-
-$$ LANGUAGE SQL;
-
--- Moran's I only for LH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialOutliers(
-    subquery TEXT,
-    attr TEXT,
-    w_type TEXT DEFAULT 'knn',
-    num_ngbrs INT DEFAULT 5,
-    permutations INT DEFAULT 99,
-    geom_col TEXT DEFAULT 'the_geom',
-    id_col TEXT DEFAULT 'cartodb_id')
-    RETURNS TABLE (moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocal(subquery, attr, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HL', 'LH');
-
-$$ LANGUAGE SQL;
-
--- Moran's I Global Rate (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_AreasOfInterestGlobalRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS TABLE (moran FLOAT, significance FLOAT)
-AS $$
-  from crankshaft.clustering import moran_local
-  # TODO: use named parameters or a dictionary
-  return moran_rate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
-
--- Moran's I Local Rate (internal function)
-CREATE OR REPLACE FUNCTION
-  _CDB_AreasOfInterestLocalRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT,
-      num_ngbrs INT,
-      permutations INT,
-      geom_col TEXT,
-      id_col TEXT)
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-  from crankshaft.clustering import moran_local_rate
-  # TODO: use named parameters or a dictionary
-  return moran_local_rate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
--- Moran's I Local Rate (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_AreasOfInterestLocalRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col);
-
-$$ LANGUAGE SQL;
-
--- Moran's I Local Rate only for HH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialHotspotsRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HH', 'HL');
-
-$$ LANGUAGE SQL;
-
--- Moran's I Local Rate only for LL and LH (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialColdspotsRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('LL', 'LH');
-
-$$ LANGUAGE SQL;
-
--- Moran's I Local Rate only for LH and HL (public-facing function)
-CREATE OR REPLACE FUNCTION
-  CDB_GetSpatialOutliersRate(
-      subquery TEXT,
-      numerator TEXT,
-      denominator TEXT,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-      permutations INT DEFAULT 99,
-      geom_col TEXT DEFAULT 'the_geom',
-      id_col TEXT DEFAULT 'cartodb_id')
-RETURNS
-TABLE(moran NUMERIC, quads TEXT, significance NUMERIC, rowid INT, vals NUMERIC)
-AS $$
-
-  SELECT moran, quads, significance, rowid, vals
-  FROM cdb_crankshaft._CDB_AreasOfInterestLocalRate(subquery, numerator, denominator, w_type, num_ngbrs, permutations, geom_col, id_col)
-  WHERE quads IN ('HL', 'LH');
-
-$$ LANGUAGE SQL;
-CREATE OR REPLACE FUNCTION  CDB_KMeans(query text, no_clusters integer,no_init integer default 20)
-RETURNS table (cartodb_id integer, cluster_no integer) as $$
-    
-    from crankshaft.clustering import kmeans
-    return kmeans(query,no_clusters,no_init)
-
-$$ language plpythonu;
-
-
-CREATE OR REPLACE FUNCTION CDB_WeightedMeanS(state Numeric[],the_geom GEOMETRY(Point, 4326), weight NUMERIC)
-RETURNS Numeric[] AS 
-$$
-DECLARE 
-    newX NUMERIC;
-    newY NUMERIC;
-    newW NUMERIC;
-BEGIN
-    IF weight IS NULL OR the_geom IS NULL THEN 
-        newX = state[1];
-        newY = state[2];
-        newW = state[3];
-    ELSE
-        newX = state[1] + ST_X(the_geom)*weight;
-        newY = state[2] + ST_Y(the_geom)*weight;
-        newW = state[3] + weight;
-    END IF;
-    RETURN Array[newX,newY,newW];
-
-END
-$$ LANGUAGE plpgsql;
-
-CREATE OR REPLACE FUNCTION CDB_WeightedMeanF(state Numeric[])
-RETURNS GEOMETRY AS 
-$$
-BEGIN
-    IF state[3] = 0 THEN 
-        RETURN ST_SetSRID(ST_MakePoint(state[1],state[2]), 4326);
-    ELSE 
-        RETURN ST_SETSRID(ST_MakePoint(state[1]/state[3], state[2]/state[3]),4326);
-    END IF;
-END
-$$ LANGUAGE plpgsql;
-
--- Create aggregate if it did not exist
-DO $$
-BEGIN
-    IF NOT EXISTS (
-        SELECT *
-        FROM pg_catalog.pg_proc p
-            LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
-        WHERE n.nspname = 'cdb_crankshaft'
-            AND p.proname = 'cdb_weightedmean'
-            AND p.proisagg)
-    THEN
-        CREATE AGGREGATE CDB_WeightedMean(geometry(Point, 4326), NUMERIC) (
-            SFUNC = CDB_WeightedMeanS,
-            FINALFUNC = CDB_WeightedMeanF,
-            STYPE = Numeric[],
-            INITCOND = "{0.0,0.0,0.0}" 
-        );
-    END IF;
-END
-$$ LANGUAGE plpgsql;
--- Spatial Markov
-
--- input table format:
--- id | geom | date_1 | date_2 | date_3
---  1 | Pt1  | 12.3   | 13.1   | 14.2
---  2 | Pt2  | 11.0   | 13.2   | 12.5
---  ...
--- Sample Function call:
--- SELECT CDB_SpatialMarkov('SELECT * FROM real_estate',
---                          Array['date_1', 'date_2', 'date_3'])
-
-CREATE OR REPLACE FUNCTION
-  CDB_SpatialMarkovTrend (
-      subquery TEXT,
-      time_cols TEXT[],
-      num_classes INT DEFAULT 7,
-      w_type TEXT DEFAULT 'knn',
-      num_ngbrs INT DEFAULT 5,
-  	  permutations INT DEFAULT 99,
-  	  geom_col TEXT DEFAULT 'the_geom',
-  	  id_col TEXT DEFAULT 'cartodb_id')
-RETURNS TABLE (trend NUMERIC, trend_up NUMERIC, trend_down NUMERIC, volatility NUMERIC, rowid INT)
-AS $$
-
-  from crankshaft.space_time_dynamics import spatial_markov_trend
-
-  ## TODO: use named parameters or a dictionary
-  return spatial_markov_trend(subquery, time_cols, num_classes, w_type, num_ngbrs, permutations, geom_col, id_col)
-$$ LANGUAGE plpythonu;
-
--- input table format: identical to above but in a predictable format
--- Sample function call:
--- SELECT cdb_spatial_markov('SELECT * FROM real_estate',
---                           'date_1')
-
-
--- CREATE OR REPLACE FUNCTION
---   cdb_spatial_markov (
---       subquery TEXT,
---       time_col_min text,
---       time_col_max text,
---       date_format text, -- '_YYYY_MM_DD'
---       num_time_per_bin INT DEFAULT 1,
---   	  permutations INT DEFAULT 99,
---   	  geom_column TEXT DEFAULT 'the_geom',
---   	  id_col TEXT DEFAULT 'cartodb_id',
---       w_type TEXT DEFAULT 'knn',
---       num_ngbrs int DEFAULT 5)
--- RETURNS TABLE (moran FLOAT, quads TEXT, significance FLOAT, ids INT)
--- AS $$
---   plpy.execute('SELECT cdb_crankshaft._cdb_crankshaft_activate_py()')
---   from crankshaft.clustering import moran_local
---   # TODO: use named parameters or a dictionary
---   return spatial_markov(subquery, time_cols, permutations, geom_column, id_col, w_type, num_ngbrs)
--- $$ LANGUAGE plpythonu;
---
--- -- input table format:
--- -- id | geom | date  | measurement
--- --  1 | Pt1  | 12/3  | 13.2
--- --  2 | Pt2  | 11/5  | 11.3
--- --  3 | Pt1  | 11/13 | 12.9
--- --  4 | Pt3  | 12/19 | 10.1
--- -- ...
---
--- CREATE OR REPLACE FUNCTION
---   cdb_spatial_markov (
---       subquery TEXT,
---       time_col text,
---       num_time_per_bin INT DEFAULT 1,
---   	  permutations INT DEFAULT 99,
---   	  geom_column TEXT DEFAULT 'the_geom',
---   	  id_col TEXT DEFAULT 'cartodb_id',
---       w_type TEXT DEFAULT 'knn',
---       num_ngbrs int DEFAULT 5)
--- RETURNS TABLE (moran FLOAT, quads TEXT, significance FLOAT, ids INT)
--- AS $$
---   plpy.execute('SELECT cdb_crankshaft._cdb_crankshaft_activate_py()')
---   from crankshaft.clustering import moran_local
---   # TODO: use named parameters or a dictionary
---   return spatial_markov(subquery, time_cols, permutations, geom_column, id_col, w_type, num_ngbrs)
--- $$ LANGUAGE plpythonu;
--- Function by Stuart Lynn for a simple interpolation of a value
--- from a polygon table over an arbitrary polygon
--- (weighted by the area proportion overlapped)
--- Aereal weighting is a very simple form of aereal interpolation.
---
--- Parameters:
---   * geom a Polygon geometry which defines the area where a value will be
---     estimated as the area-weighted sum of a given table/column
---   * target_table_name table name of the table that provides the values
---   * target_column column name of the column that provides the values
---   * schema_name optional parameter to defina the schema the target table
---     belongs to, which is necessary if its not in the search_path.
---     Note that target_table_name should never include the schema in it.
--- Return value:
---   Aereal-weighted interpolation of the column values over the geometry
-CREATE OR REPLACE
-FUNCTION cdb_overlap_sum(geom geometry, target_table_name text, target_column text, schema_name text DEFAULT NULL)
-  RETURNS numeric AS
-$$
-DECLARE
-	result numeric;
-  qualified_name text;
-BEGIN
-  IF schema_name IS NULL THEN
-    qualified_name := Format('%I', target_table_name);
-  ELSE
-    qualified_name := Format('%I.%s', schema_name, target_table_name);
-  END IF;
-  EXECUTE Format('
-    SELECT sum(%I*ST_Area(St_Intersection($1, a.the_geom))/ST_Area(a.the_geom))
-    FROM %s AS a
-    WHERE $1 && a.the_geom
-  ', target_column, qualified_name)
-  USING geom
-  INTO result;
-  RETURN result;
-END;
-$$ LANGUAGE plpgsql;
---
--- Creates N points randomly distributed arround the polygon
---
--- @param g - the geometry to be turned in to points
---
--- @param no_points - the number of points to generate
---
--- @params max_iter_per_point - the function generates points in the polygon's bounding box
--- and discards points which don't lie in the polygon. max_iter_per_point specifies how many
--- misses per point the funciton accepts before giving up.
---
--- Returns: Multipoint with the requested points
-CREATE OR REPLACE FUNCTION cdb_dot_density(geom geometry , no_points Integer, max_iter_per_point Integer DEFAULT 1000)
-RETURNS GEOMETRY AS $$
-DECLARE
-  extent GEOMETRY;
-  test_point Geometry;
-  width                NUMERIC;
-  height               NUMERIC;
-  x0                   NUMERIC;
-  y0                   NUMERIC;
-  xp                   NUMERIC;
-  yp                   NUMERIC;
-  no_left              INTEGER;
-  remaining_iterations INTEGER;
-  points               GEOMETRY[];
-  bbox_line            GEOMETRY;
-  intersection_line    GEOMETRY;
-BEGIN
-  extent  := ST_Envelope(geom);
-  width   := ST_XMax(extent) - ST_XMIN(extent);
-  height  := ST_YMax(extent) - ST_YMIN(extent);
-  x0 	  := ST_XMin(extent);
-  y0 	  := ST_YMin(extent);
-  no_left := no_points;
-
-  LOOP
-    if(no_left=0) THEN
-      EXIT;
-    END IF;
-    yp = y0 + height*random();
-    bbox_line  = ST_MakeLine(
-      ST_SetSRID(ST_MakePoint(yp, x0),4326),
-      ST_SetSRID(ST_MakePoint(yp, x0+width),4326)
-    );
-    intersection_line = ST_Intersection(bbox_line,geom);
-  	test_point = ST_LineInterpolatePoint(st_makeline(st_linemerge(intersection_line)),random());
-	  points := points || test_point;
-	  no_left = no_left - 1 ;
-  END LOOP;
-  RETURN ST_Collect(points);
-END;
-$$
-LANGUAGE plpgsql VOLATILE;
--- Make sure by default there are no permissions for publicuser
--- NOTE: this happens at extension creation time, as part of an implicit transaction.
--- REVOKE ALL PRIVILEGES ON SCHEMA cdb_crankshaft FROM PUBLIC, publicuser CASCADE;
-
--- Grant permissions on the schema to publicuser (but just the schema)
-GRANT USAGE ON SCHEMA cdb_crankshaft TO publicuser;
-
--- Revoke execute permissions on all functions in the schema by default
--- REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_crankshaft FROM PUBLIC, publicuser;

release/python/0.0.2/crankshaft/crankshaft/__init__.py

@@ -1,2 +0,0 @@
-import random_seeds
-import clustering

release/python/0.0.2/crankshaft/crankshaft/clustering/__init__.py

@@ -1 +0,0 @@
-from moran import *

release/python/0.0.2/crankshaft/crankshaft/clustering/moran.py

@@ -1,321 +0,0 @@
-"""
-Moran's I geostatistics (global clustering & outliers presence)
-"""
-
-# TODO: Fill in local neighbors which have null/NoneType values with the
-#       average of the their neighborhood
-
-import numpy as np
-import pysal as ps
-import plpy
-
-# High level interface ---------------------------------------
-
-def moran_local(t, attr, significance, num_ngbrs, permutations, geom_column, id_col, w_type):
-    """
-    Moran's I implementation for PL/Python
-    Andy Eschbacher
-    """
-    # TODO: ensure that the significance output can be smaller that 1e-3 (0.001)
-    # TODO: make a wishlist of output features (zscores, pvalues, raw local lisa, what else?)
-
-    plpy.notice('** Constructing query')
-
-    # geometries with attributes that are null are ignored
-    # resulting in a collection of not as near neighbors
-
-    qvals = {"id_col": id_col,
-            "attr1": attr,
-            "geom_col": geom_column,
-             "table": t,
-             "num_ngbrs": num_ngbrs}
-
-    q = get_query(w_type, qvals)
-
-    try:
-        r = plpy.execute(q)
-        plpy.notice('** Query returned with %d rows' % len(r))
-    except plpy.SPIError:
-        plpy.notice('** Query failed: "%s"' % q)
-        plpy.notice('** Exiting function')
-        return zip([None], [None], [None], [None])
-
-    y = get_attributes(r, 1)
-    w = get_weight(r, w_type)
-
-    # calculate LISA values
-    lisa = ps.Moran_Local(y, w)
-
-    # find units of significance
-    lisa_sig = lisa_sig_vals(lisa.p_sim, lisa.q, significance)
-
-    plpy.notice('** Finished calculations')
-
-    return zip(lisa.Is, lisa_sig, lisa.p_sim, w.id_order)
-
-
-def moran_local_rate(t, numerator, denominator, significance, num_ngbrs, permutations, geom_column, id_col, w_type):
-    """
-    Moran's I Local Rate
-    Andy Eschbacher
-    """
-
-    plpy.notice('** Constructing query')
-
-    # geometries with attributes that are null are ignored
-    # resulting in a collection of not as near neighbors
-
-    qvals = {"id_col": id_col,
-             "numerator": numerator,
-             "denominator": denominator,
-             "geom_col": geom_column,
-             "table": t,
-             "num_ngbrs": num_ngbrs}
-
-    q = get_query(w_type, qvals)
-
-    try:
-        r = plpy.execute(q)
-        plpy.notice('** Query returned with %d rows' % len(r))
-    except plpy.SPIError:
-        plpy.notice('** Query failed: "%s"' % q)
-        plpy.notice('** Error: %s' % plpy.SPIError)
-        plpy.notice('** Exiting function')
-        return zip([None], [None], [None], [None])
-
-        plpy.notice('r.nrows() = %d' % r.nrows())
-
-    ## collect attributes
-    numer = get_attributes(r, 1)
-    denom = get_attributes(r, 2)
-
-    w = get_weight(r, w_type, num_ngbrs)
-
-    # calculate LISA values
-    lisa = ps.esda.moran.Moran_Local_Rate(numer, denom, w, permutations=permutations)
-
-    # find units of significance
-    lisa_sig = lisa_sig_vals(lisa.p_sim, lisa.q, significance)
-
-    plpy.notice('** Finished calculations')
-
-    ## TODO: Decide on which return values here
-    return zip(lisa.Is, lisa_sig, lisa.p_sim, w.id_order, lisa.y)
-
-def moran_local_bv(t, attr1, attr2, significance, num_ngbrs, permutations, geom_column, id_col, w_type):
-    plpy.notice('** Constructing query')
-
-    qvals = {"num_ngbrs": num_ngbrs,
-             "attr1": attr1,
-             "attr2": attr2,
-             "table": t,
-             "geom_col": geom_column,
-             "id_col": id_col}
-
-    q = get_query(w_type, qvals)
-
-    try:
-        r = plpy.execute(q)
-        plpy.notice('** Query returned with %d rows' % len(r))
-    except plpy.SPIError:
-        plpy.notice('** Query failed: "%s"' % q)
-        plpy.notice('** Error: %s' % plpy.SPIError)
-        plpy.notice('** Exiting function')
-        return zip([None], [None], [None], [None])
-
-    ## collect attributes
-    attr1_vals = get_attributes(r, 1)
-    attr2_vals = get_attributes(r, 2)
-
-    # create weights
-    w = get_weight(r, w_type, num_ngbrs)
-
-    # calculate LISA values
-    lisa = ps.esda.moran.Moran_Local_BV(attr1_vals, attr2_vals, w)
-
-    plpy.notice("len of Is: %d" % len(lisa.Is))
-
-    # find clustering of significance
-    lisa_sig = lisa_sig_vals(lisa.p_sim, lisa.q, significance)
-
-    plpy.notice('** Finished calculations')
-
-    return zip(lisa.Is, lisa_sig, lisa.p_sim, w.id_order)
-
-
-# Low level functions ----------------------------------------
-
-def map_quads(coord):
-    """
-        Map a quadrant number to Moran's I designation
-        HH=1, LH=2, LL=3, HL=4
-        Input:
-        :param coord (int): quadrant of a specific measurement
-    """
-    if coord == 1:
-        return 'HH'
-    elif coord == 2:
-        return 'LH'
-    elif coord == 3:
-        return 'LL'
-    elif coord == 4:
-        return 'HL'
-    else:
-        return None
-
-def query_attr_select(params):
-    """
-        Create portion of SELECT statement for attributes inolved in query.
-        :param params: dict of information used in query (column names,
-                       table name, etc.)
-    """
-
-    attrs = [k for k in params
-             if k not in ('id_col', 'geom_col', 'table', 'num_ngbrs')]
-
-    template = "i.\"{%(col)s}\"::numeric As attr%(alias_num)s, "
-
-    attr_string = ""
-
-    for idx, val in enumerate(sorted(attrs)):
-        attr_string += template % {"col": val, "alias_num": idx + 1}
-
-    return attr_string
-
-def query_attr_where(params):
-    """
-        Create portion of WHERE clauses for weeding out NULL-valued geometries
-    """
-    attrs = sorted([k for k in params
-                    if k not in ('id_col', 'geom_col', 'table', 'num_ngbrs')])
-
-    attr_string = []
-
-    for attr in attrs:
-        attr_string.append("idx_replace.\"{%s}\" IS NOT NULL" % attr)
-
-    if len(attrs) == 2:
-        attr_string.append("idx_replace.\"{%s}\" <> 0" % attrs[1])
-
-    out = " AND ".join(attr_string)
-
-    return out
-
-def knn(params):
-    """SQL query for k-nearest neighbors.
-        :param vars: dict of values to fill template
-    """
-
-    attr_select = query_attr_select(params)
-    attr_where = query_attr_where(params)
-
-    replacements = {"attr_select": attr_select,
-                    "attr_where_i": attr_where.replace("idx_replace", "i"),
-                    "attr_where_j": attr_where.replace("idx_replace", "j")}
-
-    query = "SELECT " \
-                "i.\"{id_col}\" As id, " \
-                "%(attr_select)s" \
-                "(SELECT ARRAY(SELECT j.\"{id_col}\" " \
-                              "FROM \"{table}\" As j " \
-                              "WHERE %(attr_where_j)s " \
-                              "ORDER BY j.\"{geom_col}\" <-> i.\"{geom_col}\" ASC " \
-                              "LIMIT {num_ngbrs} OFFSET 1 ) " \
-                ") As neighbors " \
-            "FROM \"{table}\" As i " \
-            "WHERE " \
-                "%(attr_where_i)s " \
-            "ORDER BY i.\"{id_col}\" ASC;" % replacements
-
-    return query.format(**params)
-
-## SQL query for finding queens neighbors (all contiguous polygons)
-def queen(params):
-    """SQL query for queen neighbors.
-        :param params: dict of information to fill query
-    """
-    attr_select = query_attr_select(params)
-    attr_where = query_attr_where(params)
-
-    replacements = {"attr_select": attr_select,
-                    "attr_where_i": attr_where.replace("idx_replace", "i"),
-                    "attr_where_j": attr_where.replace("idx_replace", "j")}
-
-    query = "SELECT " \
-                "i.\"{id_col}\" As id, " \
-                "%(attr_select)s" \
-                "(SELECT ARRAY(SELECT j.\"{id_col}\" " \
-                 "FROM \"{table}\" As j " \
-                 "WHERE ST_Touches(i.\"{geom_col}\", j.\"{geom_col}\") AND " \
-                 "%(attr_where_j)s)" \
-                ") As neighbors " \
-            "FROM \"{table}\" As i " \
-            "WHERE " \
-                "%(attr_where_i)s " \
-            "ORDER BY i.\"{id_col}\" ASC;" % replacements
-
-    return query.format(**params)
-
-## to add more weight methods open a ticket or pull request
-
-def get_query(w_type, query_vals):
-    """Return requested query.
-        :param w_type: type of neighbors to calculate (knn or queen)
-        :param query_vals: values used to construct the query
-    """
-
-    if w_type == 'knn':
-        return knn(query_vals)
-    else:
-        return queen(query_vals)
-
-def get_attributes(query_res, attr_num):
-    """
-        :param query_res: query results with attributes and neighbors
-        :param attr_num: attribute number (1, 2, ...)
-    """
-    return np.array([x['attr' + str(attr_num)] for x in query_res], dtype=np.float)
-
-## Build weight object
-def get_weight(query_res, w_type='queen', num_ngbrs=5):
-    """
-        Construct PySAL weight from return value of query
-        :param query_res: query results with attributes and neighbors
-    """
-    if w_type == 'knn':
-        row_normed_weights = [1.0 / float(num_ngbrs)] * num_ngbrs
-        weights = {x['id']: row_normed_weights for x in query_res}
-    elif w_type == 'queen':
-        weights = {x['id']: [1.0 / len(x['neighbors'])] * len(x['neighbors'])
-                            if len(x['neighbors']) > 0
-                            else [] for x in query_res}
-
-    neighbors = {x['id']: x['neighbors'] for x in query_res}
-
-    return ps.W(neighbors, weights)
-
-def quad_position(quads):
-    """
-        Produce Moran's I classification based of n
-    """
-
-    lisa_sig = np.array([map_quads(q) for q in quads])
-
-    return lisa_sig
-
-def lisa_sig_vals(pvals, quads, threshold):
-    """
-        Produce Moran's I classification based of n
-    """
-
-    sig = (pvals <= threshold)
-
-    lisa_sig = np.empty(len(sig), np.chararray)
-
-    for idx, val in enumerate(sig):
-        if val:
-            lisa_sig[idx] = map_quads(quads[idx])
-        else:
-            lisa_sig[idx] = 'Not significant'
-
-    return lisa_sig

release/python/0.0.2/crankshaft/crankshaft/random_seeds.py

@@ -1,10 +0,0 @@
-import random
-import numpy
-
-def set_random_seeds(value):
-    """
-    Set the seeds of the RNGs (Random Number Generators)
-    used internally.
-    """
-    random.seed(value)
-    numpy.random.seed(value)

release/python/0.0.2/crankshaft/setup.py

@@ -1,48 +0,0 @@
-
-"""
-CartoDB Spatial Analysis Python Library
-See:
-https://github.com/CartoDB/crankshaft
-"""
-
-from setuptools import setup, find_packages
-
-setup(
-    name='crankshaft',
-
-    version='0.0.2',
-
-    description='CartoDB Spatial Analysis Python Library',
-
-    url='https://github.com/CartoDB/crankshaft',
-
-    author='Data Services Team - CartoDB',
-    author_email='dataservices@cartodb.com',
-
-    license='MIT',
-
-    classifiers=[
-        'Development Status :: 3 - Alpha',
-        'Intended Audience :: Mapping comunity',
-        'Topic :: Maps :: Mapping Tools',
-        'License :: OSI Approved :: MIT License',
-        'Programming Language :: Python :: 2.7',
-    ],
-
-    keywords='maps mapping tools spatial analysis geostatistics',
-
-    packages=find_packages(exclude=['contrib', 'docs', 'tests']),
-
-    extras_require={
-        'dev': ['unittest'],
-        'test': ['unittest', 'nose', 'mock'],
-    },
-
-    # The choice of component versions is dictated by what's
-    # provisioned in the production servers.
-    install_requires=['pysal==1.9.1'],
-
-    requires=['pysal', 'numpy' ],
-
-    test_suite='test'
-)

release/python/0.0.2/crankshaft/test/fixtures/moran.json

@@ -1,52 +0,0 @@
-[[0.9319096128346788, "HH"],
-[-1.135787401862846, "HL"],
-[0.11732030672508517, "Not significant"],
-[0.6152779669180425, "Not significant"],
-[-0.14657336660125297, "Not significant"],
-[0.6967858120189607, "Not significant"],
-[0.07949310115714454, "Not significant"],
-[0.4703198759258987, "Not significant"],
-[0.4421125200498064, "Not significant"],
-[0.5724288737143592, "Not significant"],
-[0.8970743435692062, "LL"],
-[0.18327334401918674, "Not significant"],
-[-0.01466729201304962, "Not significant"],
-[0.3481559372544409, "Not significant"],
-[0.06547094736902978, "Not significant"],
-[0.15482141569329988, "HH"],
-[0.4373841193538136, "Not significant"],
-[0.15971286468915544, "Not significant"],
-[1.0543588860308968, "Not significant"],
-[1.7372866900020818, "HH"],
-[1.091998586053999, "LL"],
-[0.1171572584252222, "Not significant"],
-[0.08438455015300014, "Not significant"],
-[0.06547094736902978, "Not significant"],
-[0.15482141569329985, "HH"],
-[1.1627044812890683, "HH"],
-[0.06547094736902978, "Not significant"],
-[0.795275137550483, "Not significant"],
-[0.18562939195219, "LL"],
-[0.3010757406693439, "Not significant"],
-[2.8205795942839376, "HH"],
-[0.11259190602909264, "Not significant"],
-[-0.07116352791516614, "Not significant"],
-[-0.09945240794119009, "Not significant"],
-[0.18562939195219, "LL"],
-[0.1832733440191868, "Not significant"],
-[-0.39054253768447705, "Not significant"],
-[-0.1672071289487642, "HL"],
-[0.3337669247916343, "Not significant"],
-[0.2584386102554792, "Not significant"],
-[-0.19733845476322634, "HL"],
-[-0.9379282899805409, "LH"],
-[-0.028770969951095866, "Not significant"],
-[0.051367269430983485, "Not significant"],
-[-0.2172548045913472, "LH"],
-[0.05136726943098351, "Not significant"],
-[0.04191046803899837, "Not significant"],
-[0.7482357030403517, "HH"],
-[-0.014585767863118111, "Not significant"],
-[0.5410013139159929, "Not significant"],
-[1.0223932668429925, "LL"],
-[1.4179402898927476, "LL"]]

release/python/0.0.2/crankshaft/test/fixtures/neighbors.json

@@ -1,54 +0,0 @@
-[
-    {"neighbors": [48, 26, 20, 9, 31], "id": 1, "value": 0.5},
-    {"neighbors": [30, 16, 46, 3, 4], "id": 2, "value": 0.7},
-    {"neighbors": [46, 30, 2, 12, 16], "id": 3, "value": 0.2},
-    {"neighbors": [18, 30, 23, 2, 52], "id": 4, "value": 0.1},
-    {"neighbors": [47, 40, 45, 37, 28], "id": 5, "value": 0.3},
-    {"neighbors": [10, 21, 41, 14, 37], "id": 6, "value": 0.05},
-    {"neighbors": [8, 17, 43, 25, 12], "id": 7, "value": 0.4},
-    {"neighbors": [17, 25, 43, 22, 7], "id": 8, "value": 0.7},
-    {"neighbors": [39, 34, 1, 26, 48], "id": 9, "value": 0.5},
-    {"neighbors": [6, 37, 5, 45, 49], "id": 10, "value": 0.04},
-    {"neighbors": [51, 41, 29, 21, 14], "id": 11, "value": 0.08},
-    {"neighbors": [44, 46, 43, 50, 3], "id": 12, "value": 0.2},
-    {"neighbors": [45, 23, 14, 28, 18], "id": 13, "value": 0.4},
-    {"neighbors": [41, 29, 13, 23, 6], "id": 14, "value": 0.2},
-    {"neighbors": [36, 27, 32, 33, 24], "id": 15, "value": 0.3},
-    {"neighbors": [19, 2, 46, 44, 28], "id": 16, "value": 0.4},
-    {"neighbors": [8, 25, 43, 7, 22], "id": 17, "value": 0.6},
-    {"neighbors": [23, 4, 29, 14, 13], "id": 18, "value": 0.3},
-    {"neighbors": [42, 16, 28, 26, 40], "id": 19, "value": 0.7},
-    {"neighbors": [1, 48, 31, 26, 42], "id": 20, "value": 0.8},
-    {"neighbors": [41, 6, 11, 14, 10], "id": 21, "value": 0.1},
-    {"neighbors": [25, 50, 43, 31, 44], "id": 22, "value": 0.4},
-    {"neighbors": [18, 13, 14, 4, 2], "id": 23, "value": 0.1},
-    {"neighbors": [33, 49, 34, 47, 27], "id": 24, "value": 0.3},
-    {"neighbors": [43, 8, 22, 17, 50], "id": 25, "value": 0.4},
-    {"neighbors": [1, 42, 20, 31, 48], "id": 26, "value": 0.6},
-    {"neighbors": [32, 15, 36, 33, 24], "id": 27, "value": 0.3},
-    {"neighbors": [40, 45, 19, 5, 13], "id": 28, "value": 0.8},
-    {"neighbors": [11, 51, 41, 14, 18], "id": 29, "value": 0.3},
-    {"neighbors": [2, 3, 4, 46, 18], "id": 30, "value": 0.1},
-    {"neighbors": [20, 26, 1, 50, 48], "id": 31, "value": 0.9},
-    {"neighbors": [27, 36, 15, 49, 24], "id": 32, "value": 0.3},
-    {"neighbors": [24, 27, 49, 34, 32], "id": 33, "value": 0.4},
-    {"neighbors": [47, 9, 39, 40, 24], "id": 34, "value": 0.3},
-    {"neighbors": [38, 51, 11, 21, 41], "id": 35, "value": 0.3},
-    {"neighbors": [15, 32, 27, 49, 33], "id": 36, "value": 0.2},
-    {"neighbors": [49, 10, 5, 47, 24], "id": 37, "value": 0.5},
-    {"neighbors": [35, 21, 51, 11, 41], "id": 38, "value": 0.4},
-    {"neighbors": [9, 34, 48, 1, 47], "id": 39, "value": 0.6},
-    {"neighbors": [28, 47, 5, 9, 34], "id": 40, "value": 0.5},
-    {"neighbors": [11, 14, 29, 21, 6], "id": 41, "value": 0.4},
-    {"neighbors": [26, 19, 1, 9, 31], "id": 42, "value": 0.2},
-    {"neighbors": [25, 12, 8, 22, 44], "id": 43, "value": 0.3},
-    {"neighbors": [12, 50, 46, 16, 43], "id": 44, "value": 0.2},
-    {"neighbors": [28, 13, 5, 40, 19], "id": 45, "value": 0.3},
-    {"neighbors": [3, 12, 44, 2, 16], "id": 46, "value": 0.2},
-    {"neighbors": [34, 40, 5, 49, 24], "id": 47, "value": 0.3},
-    {"neighbors": [1, 20, 26, 9, 39], "id": 48, "value": 0.5},
-    {"neighbors": [24, 37, 47, 5, 33], "id": 49, "value": 0.2},
-    {"neighbors": [44, 22, 31, 42, 26], "id": 50, "value": 0.6},
-    {"neighbors": [11, 29, 41, 14, 21], "id": 51, "value": 0.01},
-    {"neighbors": [4, 18, 29, 51, 23], "id": 52, "value": 0.01}
-  ]

release/python/0.0.2/crankshaft/test/helper.py

@@ -1,13 +0,0 @@
-import unittest
-
-from mock_plpy import MockPlPy
-plpy = MockPlPy()
-
-import sys
-sys.modules['plpy'] = plpy
-
-import os
-
-def fixture_file(name):
-    dir = os.path.dirname(os.path.realpath(__file__))
-    return os.path.join(dir, 'fixtures', name)

release/python/0.0.2/crankshaft/test/mock_plpy.py

@@ -1,34 +0,0 @@
-import re
-
-class MockPlPy:
-    def __init__(self):
-        self._reset()
-
-    def _reset(self):
-        self.infos = []
-        self.notices = []
-        self.debugs = []
-        self.logs = []
-        self.warnings = []
-        self.errors = []
-        self.fatals = []
-        self.executes = []
-        self.results = []
-        self.prepares = []
-        self.results = []
-
-    def _define_result(self, query, result):
-        pattern = re.compile(query, re.IGNORECASE | re.MULTILINE)
-        self.results.append([pattern, result])
-
-    def notice(self, msg):
-        self.notices.append(msg)
-
-    def info(self, msg):
-        self.infos.append(msg)
-
-    def execute(self, query): # TODO: additional arguments
-       for result in self.results:
-          if result[0].match(query):
-            return result[1]
-       return []

release/python/0.0.2/crankshaft/test/test_clustering_moran.py

@@ -1,144 +0,0 @@
-import unittest
-import numpy as np
-
-import unittest
-
-
-# from mock_plpy import MockPlPy
-# plpy = MockPlPy()
-#
-# import sys
-# sys.modules['plpy'] = plpy
-from helper import plpy, fixture_file
-
-import crankshaft.clustering as cc
-from crankshaft import random_seeds
-import json
-
-class MoranTest(unittest.TestCase):
-    """Testing class for Moran's I functions."""
-
-    def setUp(self):
-        plpy._reset()
-        self.params = {"id_col": "cartodb_id",
-                       "attr1": "andy",
-                       "attr2": "jay_z",
-                       "table": "a_list",
-                       "geom_col": "the_geom",
-                       "num_ngbrs": 321}
-        self.neighbors_data = json.loads(open(fixture_file('neighbors.json')).read())
-        self.moran_data = json.loads(open(fixture_file('moran.json')).read())
-
-    def test_map_quads(self):
-        """Test map_quads."""
-        self.assertEqual(cc.map_quads(1), 'HH')
-        self.assertEqual(cc.map_quads(2), 'LH')
-        self.assertEqual(cc.map_quads(3), 'LL')
-        self.assertEqual(cc.map_quads(4), 'HL')
-        self.assertEqual(cc.map_quads(33), None)
-        self.assertEqual(cc.map_quads('andy'), None)
-
-    def test_query_attr_select(self):
-        """Test query_attr_select."""
-
-        ans = "i.\"{attr1}\"::numeric As attr1, " \
-              "i.\"{attr2}\"::numeric As attr2, "
-
-        self.assertEqual(cc.query_attr_select(self.params), ans)
-
-    def test_query_attr_where(self):
-        """Test query_attr_where."""
-
-        ans = "idx_replace.\"{attr1}\" IS NOT NULL AND "\
-              "idx_replace.\"{attr2}\" IS NOT NULL AND "\
-              "idx_replace.\"{attr2}\" <> 0"
-
-        self.assertEqual(cc.query_attr_where(self.params), ans)
-
-    def test_knn(self):
-        """Test knn function."""
-
-        ans = "SELECT i.\"cartodb_id\" As id, i.\"andy\"::numeric As attr1, " \
-              "i.\"jay_z\"::numeric As attr2, (SELECT ARRAY(SELECT j.\"cartodb_id\" " \
-              "FROM \"a_list\" As j WHERE j.\"andy\" IS NOT NULL AND " \
-              "j.\"jay_z\" IS NOT NULL AND j.\"jay_z\" <> 0 ORDER BY " \
-              "j.\"the_geom\" <-> i.\"the_geom\" ASC LIMIT 321 OFFSET 1 ) ) " \
-              "As neighbors FROM \"a_list\" As i WHERE i.\"andy\" IS NOT " \
-              "NULL AND i.\"jay_z\" IS NOT NULL AND i.\"jay_z\" <> 0 ORDER " \
-              "BY i.\"cartodb_id\" ASC;"
-
-        self.assertEqual(cc.knn(self.params), ans)
-
-    def test_queen(self):
-        """Test queen neighbors function."""
-
-        ans = "SELECT i.\"cartodb_id\" As id, i.\"andy\"::numeric As attr1, " \
-              "i.\"jay_z\"::numeric As attr2, (SELECT ARRAY(SELECT " \
-              "j.\"cartodb_id\" FROM \"a_list\" As j WHERE ST_Touches(" \
-              "i.\"the_geom\", j.\"the_geom\") AND j.\"andy\" IS NOT NULL " \
-              "AND j.\"jay_z\" IS NOT NULL AND j.\"jay_z\" <> 0)) As " \
-              "neighbors FROM \"a_list\" As i WHERE i.\"andy\" IS NOT NULL " \
-              "AND i.\"jay_z\" IS NOT NULL AND i.\"jay_z\" <> 0 ORDER BY " \
-              "i.\"cartodb_id\" ASC;"
-
-        self.assertEqual(cc.queen(self.params), ans)
-
-    def test_get_query(self):
-        """Test get_query."""
-
-        ans = "SELECT i.\"cartodb_id\" As id, i.\"andy\"::numeric As attr1, " \
-              "i.\"jay_z\"::numeric As attr2, (SELECT ARRAY(SELECT " \
-              "j.\"cartodb_id\" FROM \"a_list\" As j WHERE j.\"andy\" IS " \
-              "NOT NULL AND j.\"jay_z\" IS NOT NULL AND j.\"jay_z\" <> 0 " \
-              "ORDER BY j.\"the_geom\" <-> i.\"the_geom\" ASC LIMIT 321 " \
-              "OFFSET 1 ) ) As neighbors FROM \"a_list\" As i WHERE " \
-              "i.\"andy\" IS NOT NULL AND i.\"jay_z\" IS NOT NULL AND " \
-              "i.\"jay_z\" <> 0 ORDER BY i.\"cartodb_id\" ASC;"
-
-        self.assertEqual(cc.get_query('knn', self.params), ans)
-
-    def test_get_attributes(self):
-        """Test get_attributes."""
-
-        ## need to add tests
-
-        self.assertEqual(True, True)
-
-    def test_get_weight(self):
-        """Test get_weight."""
-
-        self.assertEqual(True, True)
-
-
-    def test_quad_position(self):
-        """Test lisa_sig_vals."""
-
-        quads = np.array([1, 2, 3, 4], np.int)
-
-        ans = np.array(['HH', 'LH', 'LL', 'HL'])
-        test_ans = cc.quad_position(quads)
-
-        self.assertTrue((test_ans == ans).all())
-
-    def test_moran_local(self):
-        """Test Moran's I local"""
-        data = [ { 'id': d['id'], 'attr1': d['value'], 'neighbors': d['neighbors'] } for d in self.neighbors_data]
-        plpy._define_result('select', data)
-        random_seeds.set_random_seeds(1234)
-        result = cc.moran_local('table', 'value', 0.05, 5, 99, 'the_geom', 'cartodb_id', 'knn')
-        result = [(row[0], row[1]) for row in result]
-        expected = self.moran_data
-        for ([res_val, res_quad], [exp_val, exp_quad]) in zip(result, expected):
-            self.assertAlmostEqual(res_val, exp_val)
-            self.assertEqual(res_quad, exp_quad)
-
-    def test_moran_local_rate(self):
-        """Test Moran's I rate"""
-        data = [ { 'id': d['id'], 'attr1': d['value'], 'attr2': 1, 'neighbors': d['neighbors'] } for d in self.neighbors_data]
-        plpy._define_result('select', data)
-        random_seeds.set_random_seeds(1234)
-        result = cc.moran_local_rate('table', 'numerator', 'denominator', 0.05, 5, 99, 'the_geom', 'cartodb_id', 'knn')
-        result = [(row[0], row[1]) for row in result]
-        expected = self.moran_data
-        for ([res_val, res_quad], [exp_val, exp_quad]) in zip(result, expected):
-            self.assertAlmostEqual(res_val, exp_val)

release/python/0.0.3/crankshaft/crankshaft/__init__.py

@@ -1,2 +0,0 @@
-import random_seeds
-import clustering