Contiguity | Tool for visualising assemblies | Genomics library

I need to issue job IDs that are both concurrent and as contiguous as possible, ideally in a fairly seamless and lightweight manner. I'm using SQLAlchemy and Postgresql.

I only want the issued ID to be considered taken if the job was successful and the ID persisted in the newly written DB row. This way there will be no gaps in the issued IDs in the DB. If the DB transaction fails during the job, I want that ID to be freed up for the next job. If the first ID to be issued is 1 and the first 5 jobs all fail, I want the 6th job attempt to be issued the ID 1, not 6.

I could take max(ID) + 1 for the next ID, but this doesn't work for concurrent requests, since all concurrent jobs will take the same number.

I understand that contiguousness is not guaranteed. If 5 jobs are launched simultaneously, each taking the IDs 1-5, and only #5 survives, I'll just have #5 persisted. That's OK. I have low concurrency and a large number of job failures and without attempting contiguity, I'd have gaping holes in the sequences. Requests are not often concurrent, so the likelihood of a gap is low. The result will be at most an occasional small gap.

1. I could write a service that issues IDs to concurrent jobs, but it would need a way to know if the client job has failed in order to free up the ID. It's also a single point of failure and too much additional engineering for this.
2. I was thinking of having each job put max(ID) + 1 in a temporary table in the DB in such a way that other jobs could see the uncommitted change. If the transaction fails, the new ID also falls off with it. In this sense, all jobs would actually pick max(ID of completed jobs, uncommitted IDs in the temp table) + 1. If the new ID commits, I no longer need it anyway and can delete it from the temp table. It's an awkward pattern and not sure how I would do it.
3. I could do the above but commit the IDs in progress instead and delete them on successful job completion. The table would thus represent "in process" IDs. Without a way to delete those IDs for failed transactions though, I'd need some kind of periodic pruning to delete "abandoned" IDs based on age or some less than ideal heuristic.
4. I could do the above and include a PID in the table. A periodic process would delete rows where the PID is no longer valid, but that solution won't scale to a distributed setup and I'd prefer not to have a polling process active all the time for the system to function.
5. Or maybe use a DB session ID instead of PID? At least that's distributable and I could catch invalid DB sessions more quickly and easily? But my application may need admin privileges to check if DB session IDs are valid.
6. The ideal solution for me is #3 + if there were a way in SQLAlchemy to run some DB code only when a transaction fails. I assume all failures will appear as an exception in Python, so maybe some kind of global except() block, but it might get messy trying to separate DB transaction failures from other Python exceptions that I don't want to catch globally. It would be better if I could register some cleanup code with SQLAlchemy to run whenever a transaction fails, which would delete the issued ID.
7. Something similar but on the DB, like a trigger on transaction failure.
8. I could issue a UUID as the job number and upon successful transaction commit, map the UUID to max(ID) + 1 at that point, but I'm not sure if it's concurrent and it would be tedious because the ID is stamped on a bunch of files created during the job, so I'd have to go around renaming everything on disk.
9. Leverage Postgresql Sequences somehow? But they don't seem to care about contiguity.

Is there any nifty approach to this? If not, I'm leaning towards #3 because of its simplicity.

I'm trying to implement an algorithm that from six 2-D matrices of X,Y,Z points store them in a 3D matrix of X,Y,Z points in such a manner that their connectivity is preserved. An example will clarify the problem.

I've to represent with three 3-D matrices

JavaScript is far from a familiar language to me. I have a piece of logic I am trying to optimise for speed. It consists in finding the argmax, row and columns index, of the a 2d array (rectangular shaped). At the moment, I have a naïve implementation

This is a continuation of another question I have asked before (Dataframe add element from a column based on values contiguity from another columns), I got the solution if I use a pandas DataFrame, but not if I have 2 lists, and here is where I am stuck.

I have 2 lists:

I am currently working on the implementation of a multidimensional array iterator. Considering the iteration over two contiguous ranges (for std::equal, std::copy purposes) that represent compatible data with different alignements (row vs col major in 2D), I would like to find the stride order for each iterator giving the fastest execution time.

For example:

I've encountered what appears to be an anomaly in how ListChangeListener handles batch removals (i.e. removeAll(Collection). If the items in the Collection are contiguous then the handling operation specified in the listener works fine. However, if the Collection are not contiguous then the operation specified in the listener halts once contiguity is broken.

This can best be explained by way of example. Assume the ObservableList consists of the following items:

• "red"
• "orange"
• "yellow"
• "green"
• "blue"

Assume also that there is a separate ObservableList that tracks the hashCode values for the colors, and that a ListChangeListener has been added that removes the hashCode from the second list whenever one or more of the items in the first list is removed. If the 'removal' Collection consists of "red", "orange" and "yellow" then the code in the listener removes the hashCodes for all three items from the second list as expected. However, if the 'removal' Collection consists of "red", "orange" and "green", then the code in the listener stops after removing the hashCode for "orange" and never reaches "green" like it should.

A short app that illustrates the problem is set out below. The listener code is in a method named buildListChangeListener() that returns a listener that is added to the 'Colors' list. To run the app it helps to know that:

• 'consecutive' in the ComboBox specifies three colors that are contiguous as explained above; clicking the 'Remove' button will cause them to be removed from the 'Colors' list and their hashCodes from the other list.
• 'broken' specifies three colors that are not contiguous, so that clicking the 'Remove' button removes only one of the colors
• clicking 'Refresh' restores both lists to their original state

Here's the code for the app:

Given the following polygon, which is divided into sub-polygons as depicted below [left], I would like to create n number of contiguous, equally sized groups of sub-polygons [right, where n=6]. There is no regular pattern to the sub-polygons, though they are guaranteed to be contiguous and without holes.

This is not splitting a polygon into equal shapes, it is grouping its sub-polygons into equal, contiguous groups. The initial polygon may not have a number of sub-polygons divisible by n, and in these cases non-equally sized groups are ok. The only data I have is n, the number of groups to create, and the coordinates of the sub-polygons and their outer shell (generated through a clipping library).

My current algorithm is as follows:

As per this answer:

std::vector of std::vectors contiguity

A vector of vectors is not contiguous. EASTL claims that their vector is contgiuous (see: https://github.com/electronicarts/EASTL/blob/master/include/EASTL/vector.h it). Does this contiguity apply to a vector of vectors?

I would like to create a map showing the bi-variate spatial correlation between two variables. This could be done either by doing a LISA map of bivariate Moran's I spatial correlation or using the L index proposed by Lee (2001).

The bi-variate Moran's I is not implemented in the spdep library, but the L index is, so here is what I've tried without success using the L index. A answer showing a solution based on Moran's I would also be very welcomed !

As you can see from the reproducible example below, I've manged so far to calculate the local L indexes. What I would like to do is to estimate the pseudo p-values and create a map of the results like those maps we use in LISA spatial clusters with high-high, high-low, ..., low-low.

In this example, the goal is to create a map with bi-variate Lisa association between black and white population. The map should be created in ggplot2 , showing the clusters:

• High-presence of black and High-presence of white people
• High-presence of black and Low-presence of white people
• Low-presence of black and High-presence of white people
• Low-presence of black and Low-presence oh white people