CCL | DESC Core Cosmology Library : cosmology routines

The specification says:

setf will not accept the reader function for this slot.

slot-value is not the reader function created by defstruct. The reader function is foo-one (unless you override the naming scheme with the :conc-name keyword). So you should get an error if you try to do

• no sample data so I've simulated it
• start by simplifying axis list returned by plt.subplots() to 1D
• iterate over tickers in columns level 1 index
• simple plot() with above steps
• tight_layout() over compresses for me so have commented

This is what you are looking for -

When using entity framework you can eagerly load entities with an Include call.

Something like the following

It's not exactly clear. The spec says:

Executes forms in a dynamic environment where the indicated handler bindings are in effect.

and then says

If an appropriate type is found, the associated handler is run in a dynamic environment where none of these handler bindings are visible (to avoid recursive errors).

If you interpret "run" meaning to call the function, that suggests that the handler expressions are evaluted once, when the bindings are made. This is the CCL/ABCL/ECL/LispWorks implementation, so state is maintained in the closure.

But SBCL appears to have intepreted "run" as meaning "evaluated and called". So a new closure is created each time the handler is run, and state is lost.

I suspect the intent was the first interpretation, since CL has no other "lazy" bindings.

If you change the code in the question to this:

Looking at your command, an error occurred in the process of enrolling the admin client.
this process is a command that requests enroll from Fabric-CA, and Fabric-CA must be up.

However, in the case of the command ./network.sh up createChannel you entered, Fabric-CA is not up.
You need to add a parameter option to up Fabric-CA.

See the command usage for ./network.sh

• https://hyperledger-fabric.readthedocs.io/en/release-2.3/test_network.html

My reasoning was getting too long for a comment, so here we are. There is a lot to unpack. I like the question quite a bit even though it might be better suited for a computer science site.

The thing is, there are two layers to this question:

1. Was a new algorithm discovered?
2. What about the bit scanning part?

You are combining these two so first I will explain why I would like to think about them separately:
The algorithm is a set of steps(more formal definition) that is language-agnostic. As such it should work even without the need for the bitscanning.
The bit scanning on the other hand I would consider to be an optimization technique - we are using a structure that the computer is comfortable with which can bring us performance gains.

Unless we separate these two, the question gets a bit fuzzy since there are several possible scenarios that can be happening:

1. The algorithm is new and improved and bit scanning makes it even faster. That would be awesome.
2. The algorithm is just a new way of saying "two pass" or something similar. That would still be good if it beats the benchmarks. In this case it might be worth adding to a library for the CCL.
3. The algorithm is a good fit for some cases but somehow fails in others(speed-wise, not correction wise). The bit scanning here makes the comparison difficult.
4. The algorithm is a good fit for some cases but completely fails in others(produces incorrect result). You just didn't find a counterexample yet.

Let us assume that 4 isn't the case and we want to decide between 1 to 3. In each case, the bit scanning is making things fuzzy since it most likely speeds up things even more - so in some cases even a slower algorithm could outperform a better one.

So first I would try and remove the bit scanning and re-evaluate the performance. After a quick look it seems that the algorithms for the CCL have a linear complexity, depending on the image size - you need to check every pixel at least once. Rest is the fight for lowering the constant as much as possible. (Number of passes, number of neighbors to check etc.) I think it is safe to assume, that you can't do better then linear - so the first question is: does your algorithm improve on the complexity by a multiplicative constant? Since the algorithm is linear, the factor directly translates to performance which is nice.

Second question would then be: Does bit scanning further improve the performance of the algorithm?

Also, since I already started thinking about it, what about a chess-board pattern and 4-connectivity? Or alternatively, a chessboard of 3x3 crosses for the 8-connectivity.

While I was not able to accomplish my task using matplotlib I came across a tutorial for plotly and dash while searching for the answer. There is one such wonderful tutorial here:

Plotly Line Graph Tutorial

From the test network documentation, "The deployCC subcommand will install the asset-transfer (basic) chaincode on peer0.org1.example.com and peer0.org2.example.com and then deploy the chaincode on the channel specified using the channel flag (or mychannel if no channel is specified)."

You should still be able to deploy your chaincode but you'll need to use the Fabric peer command directly instead of the test network scripts. The process is described in the Deploying a smart contract to a channel tutorial and there is more detail in the Fabric chaincode lifecycle documentation.