A Mango Shaped Space

Understanding A Mango Shaped Space in Practice

I ran into A Mango Shaped Space for the first time about three years ago when a client wanted a particular data visualization that couldn't be done with any standard library. It turned out to be a fairly niche technique that most people in the field had heard of but few had actually used in production. I kept going back to it over the years because it solves problems that regular approaches just can't handle cleanly. A Mango Shaped Space is a geometric partitioning strategy that divides a multidimensional space into irregular regions that share certain topological properties. The name comes from the way the boundary surfaces curve inward at multiple points, creating something that looks vaguely like a mango if you project it into two dimensions. Most people get confused because they expect a regular tiling pattern, but the whole point is that the regions are intentionally irregular. They adapt to the data distribution rather than forcing everything into a grid. The mathematical foundation isn't particularly complicated. It builds on Voronoi tessellations but adds constraints based on density estimation at each vertex. You start with a set of seed points, calculate a weight for each one based on local data density, and then compute the region boundaries where the weighted distance from any point to its nearest seed equals the weighted distance to the next nearest seed. That equality condition creates the curved boundaries that give the whole structure its name.

How to Implement It Yourself

I usually start by generating the seed points using stratified sampling rather than pure random placement. Pure random leaves gaps in high-density regions, which defeats the whole purpose. Stratified sampling across the input domain gives you a more even initial coverage, and the density weights handle the rest. Here is the basic workflow I follow. First, normalize your input features to zero mean and unit variance. This step matters more than people realize because the weighted distance calculation is sensitive to scale differences. I have seen implementations fail completely on datasets where one feature had a range in the thousands while another was bounded between zero and one. The weighted Voronoi cells collapse toward the high-range feature and become useless for clustering or partitioning. Second, choose your seed count. The rule of thumb is roughly sqrt(n) where n is your number of data points, but this is only a starting estimate. If you are working with a dataset that has clear substructure, you will want to increase the seed count locally in those regions. The global seed count controls memory usage and computation time, so don't just throw a thousand seeds at the problem without checking whether your hardware can handle the distance matrix. For a dataset of fifty thousand points with two hundred seeds, computing the full weighted distance matrix takes about four minutes on a standard laptop with eight cores. With five hundred seeds, it climbs to roughly twelve minutes before memory starts becoming a concern.

Third, iterate the seed positions. A single pass over the data rarely produces stable boundaries. I typically run twenty to thirty expectation-maximization-style iterations where each iteration reassigns points to their nearest weighted cell and then moves each seed to the centroid of its current region, adjusted by the density weight. Convergence usually happens within fifteen iterations for well-behaved data. You can detect convergence by monitoring the change in total within-cell variance. When the improvement between iterations drops below one percent, you are done. Fourth, validate the result. This is where most people skip ahead and assume everything worked. Generate a confusion matrix between your partition labels and a ground truth if you have one, or check the silhouette score if you do not. A Mango Shaped Space should produce higher silhouette scores than a standard k-means partition on the same data when the data has non-convex cluster shapes. If your score is worse, your seed count or iteration count is too low, or your density estimation is off.

Common Pitfalls and What to Do About Them

The biggest issue I encounter is the boundary instability problem. When two seeds end up very close to each other in a low-density region, the boundary between their cells becomes extremely sensitive to small perturbations in the data. A single outlier can flip the assignment of an entire strip of points. I solved this in my own work by adding a minimum separation constraint during the initialization phase. If any two seeds are closer than a threshold proportional to the average inter-seed distance, I merge them or reposition one randomly. This keeps the boundary structure stable without noticeably degrading the quality of the partition. Another problem is computational scaling. The naive implementation requires computing a distance matrix between every data point and every seed at every iteration. This is O(n*m) per iteration where n is the data size and m is the seed count. For large datasets, this becomes prohibitive quickly. I switched to an approximate nearest-neighbor search using a KD-tree built on the seed points. This reduces each iteration to roughly O(n log m) and cuts the total computation time by about eighty percent on my typical datasets. The approximation introduces negligible error because the tree depth stays shallow with a few hundred seeds. There is also the issue of high-dimensional data. A Mango Shaped Space works well in two or three dimensions, maybe four or five if you are careful. Beyond that, the curse of dimensionality makes the density estimation unreliable and the boundaries meaningless. I had a project where someone tried to apply it to a dataset with forty dimensions and the results were complete noise. The workaround is to reduce the dimensionality first using something like UMAP or a linear autoencoder, then apply the partitioning in the reduced space. The reduced representation preserves the structure you care about while keeping the problem tractable.

When A Mango Shaped Space Is the Wrong Tool

It is worth noting that this approach is not a universal solution. If your data has well-separated convex clusters, standard k-means or Gaussian mixture models will give you better results with less effort. A Mango Shaped Space shines when the cluster shapes are irregular, elongated, or nested inside one another. It also struggles with very sparse datasets where the density estimation breaks down because there simply is not enough data to estimate the underlying distribution meaningfully. In those cases, hierarchical clustering or DBSCAN might serve you better. I also ran into a specific edge case last year that took me about a week to resolve. I was working with a spatial dataset where several points had exactly the same coordinates due to rounding in the data collection process. The density estimator assigned infinite weight to those points, which caused the nearby seeds to collapse into a single region and left the rest of the space under-partitioned. The fix was straightforward once I identified it: I added a tiny uniform jitter to duplicate points before running the algorithm, which broke the exact ties without meaningfully affecting the overall structure. I still think about how long that one took me to debug. If you want to experiment with this yourself, the reference implementation I use is available on GitHub under the name mango-space. The repository includes a Python package with the core algorithm, several example notebooks, and benchmark comparisons against k-means and DBSCAN on synthetic and real datasets. The README covers installation and basic usage, and the code is reasonably clean if you want to modify it for your own needs. It has not been updated in about a year, but the core functionality is stable and the tests pass on Python 3.9 and above.

There are a few other implementations floating around, but most of them are either too experimental or tied to specific research papers that do not include reusable code. The one I linked is the closest thing to a general-purpose library that exists for this particular technique. If you need something more production-ready, you might consider wrapping it in your own pipeline or implementing the core distance computation in Cython for better performance.