tic | Bit9 Carbon Black Threat Intelligence

Which gnuplot version and which terminal are you using? The following should work from gnuplot >=5.0.0 with wxt terminal.

Code:

It sounds like you're looking for this:

There are few things that need to be fixed.

1. In your handleClick, you are using setSquares((squares) => squares.splice(i, 1, "X")). squares.splice will mutate the state variable squares which one should never do.
2. Also splice doesn't return updated array but

An array containing the deleted elements.

This causes squares from [null, null, null, null, null, null, null, null, null] to [null] causing you board to become blank for a moment. Then your setSquares((squares) => [...squares2]) kicks in from setTimeout making squares back to array making your square values visible again hence, the flash.

1. computersTurnHandler might return undefined in some cases where none of the return statements trigger hence

Uncaught TypeError: squares2 is undefined handleClick Board.js:34

1. You need to prevent user from clicking until your setTimeout is complete else multiple rapid clicks by user will cause inconsistent behaviour.

As for your query

is it acceptable at all to use Promises in that case

Usually situations like these can simply be solved by making use of temporary variable in most cases.

Now the Solution with promise and fixed handleClick and computersTurnHandler is as follows

You call a function with player_1=symbolchoose() and put the return value into the variable player_1. But when you define your function symbolchoose() you do not return anything.

So instead of calling pass at the end of your functions, use return player_2 or whatever variable you need.

See https://www.geeksforgeeks.org/python-return-statement/#:~:text=A%20return%20statement%20is%20used,special%20value%20None%20is%20returned. or google return. This is important to use functions correctly!

You should have a crack at this yourself so I don't want to code an answer for you... but here are some of the pieces and the thinking.

You can check to see if a player has won immediately after they click for their turn, so at the end of the handleClick function.

A rough and ready way to do this would be to gather all of the "box" elements, then check all the rows, columns and diagonals.

Some of the pieces of this include:

• Use the document.getElementById method to get the "box" elements into variables (ideally an array or map to make it easy to refer to the elements in a logical, rather than manual, way, but individual variables would work)
• Test those variables for winning lines, so a crude example for testing one winning line would be (where box1, box2 and box3 were the box elements from the previous step, and processWin some function which did whatever was needed when a win happened):

You are in a FOR-LOOP and you try to add same "iv" multiple times to its "ttt" parent, so after one cycle "iv" already has a Parent....

Method rewritten (2nd time):

As I understand the documentation (check help xtics) you can have the tics either at the axis or at the border but not both.

TL;DR: the C++ code and Numpy do not use the same matrix-multiplication library.

The matrix multiplication of the GSL library is not optimized. On my machine, it runs sequentially, does not use SIMD instructions (SSE/AVX), does not efficiently unroll the loops to perform register tiling. I also suspect it also does not use the CPU cache efficiently due to the lack of tiling. These optimizations are critical to achieve high-performance and widely used in fast linear algebra libraries.

Numpy uses a BLAS library installed on your machine. On many Linux platform, its uses OpenBLAS or the Intel MKL. Both are very fast (they use all the methods described above) and should run in parallel.

You can find which implementation of BLAS is used by Numpy here. On my Linux machine, Numpy use by default CBLAS which internally use OpenBLAS (OpenBLAS is strangely not directly detected by Numpy).

There are many fast parallel BLAS implementations (GotoBLAS, ATLAS, BLIS, etc.). The open-source BLIS library is great because its matrix multiplication is very fast on many different architectures.

As a result, the simplest way to improve your C++ code is to use the cblas_sgemm CBLAS function and link a fast BLAS library like OpenBLAS or BLIS for example.

For more information:

One simple way to see how bad the GSL perform is to use a profiler (like perf on Linux or VTune on Windows). In your case Linux perf, report that >99% of the time is spent in libgslcblas.so (ie. the GSL library). More specifically, most of the execution time is spent in this following assembly loop:

Your .btn-1 styling is aligning the elements based on their text content, this can be solved by applying vertical-align: top; to that class.

Another small change that's worth making would be to change .item-board from inline-block to display: block, as that will prevent the width of the screen affecting whether the rows wrap.