boards | Data Visualization for NBA Statistics | Data Visualization library

Axios is a Promised-based JavaScript library that is used to send HTTP requests, you have to get the promise result in the then method . try this

Some tests could be grouped together.

For example, let's say the board is called x, then m = x & (x >> 1) & (x >> 2) & (x >> 3) & (x >> 4) computes a mask where every bit indicates whether it is the start of 5 horizontally-consecutive set bits (including ranges that wrap across different rows). If m has any of the bits in the first two columns set, then that means that that bit is the first bit of a winning position. That's a cheap test: (m & 0b000011000011000011000011000011000011) != 0. Together that takes care of checking 12 winning positions in 10 operations.

The same approach can be used for vertical alignment, but the shift amounts become 6, 12, 18, 24 instead of 1, 2, 3, 4 and the mask becomes 0b000000000000000000000000111111111111.

The same approach can also be used for the diagonals,

• shift amounts of 7, 14, 21, 28 with a mask of 0b000011000011
• shift amounts of 5, 10, 15, 20 with a mask of 0b110000110000

But there are only 8 diagonal winning positions and it ends up costing 20 operations to check them this way, which isn't that good. It may still help thanks to reducing the number of checks even though it's more operations, but it may also not help, or be worse.

The number of checks can be reduced to 1 if you prefer, by ORing together the winning-position bits and doing just one != 0.

I'm not an expert in typescript, but here's my take

1. How does typescript know about this file when it is named as env.d.ts

In tsconfig.json you have

You could use combn by each name with a small case handling.

My problem is that board.c (as well as main.c) depends on somelib. How can I add this dependency to the subdirectory CMakeLists.txt? Is there a way I can do that without hard-coding a path to somelib? My feeling is that I should create a CMakeLists.txt in somelib, and I feel this would be easy if I were handling the library linking from the root CMakeLists.txt, but my confusion is that board is adjacent to lib. I'm relatively new to CMake and am not sure how to best structure these dependencies.

This is very straightforward start by linking each board_ to somelib's target.

how I can create a project which allows me to build an executable for either board where each executable can have a separate set of defines

Put CMakeLists.txt inside board_a that does add_library(board_a board.c).

Put CMakeLists.txt inside board_b that does add_library(board_b board.c).

If the boards are somewhat similar:

• In the root CMakeLists.txt create a add_executable(exe_board_a main.c) that target_link_libraries(exe_board_a PUBLIC board_a).
• Repeat above for exe_board_b

If the boards are unrelated, like need many different compiler flags or separate toolchain files or even different compilers:

• In the root CMakeLists.txt add_executable(exe main.c) that does target_link_libraries(exe PUBLIC ${USE_BOARD}).

• Compile your project twice with cmake -DUSE_BOARD=board_a and cmake -DUSE_BOARD=board_b. Use two separate build directories. The double compilation can be scripted with a custom script, a root custom Makefile, or you can research cmake-presets.

Remember to use target_* commands, not the directory specific commands.

I compared the instruction cycle timing of A72 and A55 (nothing available on A53):

vshl and vshr:

A72: throughput(IPC) 1, latency 3, executes on F1 pipeline only
A55: throughput(IPC) 2, latency 2, executes on both pipelines (restricted though)

That pretty much nails it since there are many of them in your code.

There are some drawbacks in your assembly code, too:

1. vadd has less restrictions and better throughput/latency than vshl. You should replace all vshl by immediate 1 with vadd. Barrel shifters are more costly than arithmetic on SIMD.
2. You should not repeat the same instructions unnecesarily (<<5)
3. The second vmvn is unnecessary. You can replace all the following vand with vbic instead.
4. Compilers generate acceptable machine codes as long as no permutations are involved. Hence I'd write the code in neon intrinsics in this case.

I may be wrong but it looks like you are only passing two items when calling listArticle method.

How it's defined: listArticle(param, success, fail)

How it's called: listArticle((response) => {}, (error) => {});

How it should be called: listArticle(param, (response) => {}, (error) => {});

Does the items in the response.data have a data prop as used in props.item.data.articleno? I'm guessing data does not exist so key articleno can't be found and there is a browser error accessing nested values causing the slots to not be displayed.

Other suggestions (may not fix):

• Wrap the two s inside (unless it's already part of item slot template, check in DOM if you get any rows to show up)
• Deconstruct v-slot props so you don't have to reference it as props.item

I looked at another generator code, and it repeatedly chooses a tile to consider blackening, doing so if that doesn’t lead to an invalid board. If your generator works the same way, we can exploit the relatedness of the connectivity queries. The resulting algorithm will require O(n²)-time initialization and then process each update in amortized O(log n) time (actually inverse Ackermann if you implement balanced disjoint set merges). The constants should be OK as algorithms go, though n = 15 is small.

Treating the board as a subset of the grid graph with the black tiles removed, we need to detect when the number of connected components would increase from 1. To borrow an idea from my colleague Jakub Łącki and Piotr Sankowski (“Optimal Decremental Connectivity in Planar Graphs”, Lemma 2), we can use Euler characteristic and planar duality to help accomplish this.

Let me draw an empty board (with numbered tiles) and its grid graph.