translate | A module grouping multiple translation APIs | Translation library

I found a way to accomplish it. This is what needed

Just remove the "extractCss": true from your production environment, it will resolve the problem.

The reason about it is extractCss is deprecated, and it's value is true by default. See more here: Extracting CSS into JS with Angular 11 (deprecated extractCss)

I managed to make this function that does exactly what you want.

You can see the cost of instructions on most mainstream architecture here and there. Based on that and assuming you use for example an Intel Skylake processor, you can see that one 32-bit imul instruction can be computed per cycle but with a latency of 3 cycles. In the optimized code, 2 lea instructions (which are very cheap) can be executed per cycle with a 1 cycle latency. The same thing apply for the sal instruction (2 per cycle and 1 cycle of latency).

This means that the optimized version can be executed with only 2 cycle of latency while the first one takes 3 cycle of latency (not taking into account load/store instructions that are the same). Moreover, the second version can be better pipelined since the two instructions can be executed for two different input data in parallel thanks to a superscalar out-of-order execution. Note that two loads can be executed in parallel too although only one store can be executed in parallel per cycle. This means that the execution is bounded by the throughput of store instructions. Overall, only 1 value can only computed per cycle. AFAIK, recent Intel Icelake processors can do two stores in parallel like new AMD Ryzen processors. The second one is expected to be as fast or possibly faster on the chosen use-case (Intel Skylake processors). It should be significantly faster on very recent x86-64 processors.

Note that the lea instruction is very fast because the multiply-add is done on a dedicated CPU unit (hard-wired shifters) and it only supports some specific constant for the multiplication (supported factors are 1, 2, 4 and 8, which mean that lea can be used to multiply an integer by the constants 2, 3, 4, 5, 8 and 9). This is why lea is faster than imul/mul.

I can reproduce the slower execution with -O2 using GCC 11.2 (on Linux with a i5-9600KF processor).

The main source of source of slowdown comes from the higher number of micro-operations (uops) to be executed in the -O2 version certainly combined with the saturation of some execution ports certainly due to a bad micro-operation scheduling.

Here is the assembly of the loop with -Os:

The issue is that you are trying to do a string.Contains within an Any expression which EF will choke on trying to compose down to SQL. Cleptus is on the nose, to build a predicate for the Where clause OR-ing the term comparisons. Otherwise your code should work without the contains check, but rather an equality check:

Without Contains: (equality check rather than LIKE %name%)

The Compose file also has a top-level volumes: block and you need to declare volumes there.

Most of the solutions here would be used with melt, so to know the method melt, see the documentaion explanation

Unpivot a DataFrame from wide to long format, optionally leaving identifiers set.

This function is useful to massage a DataFrame into a format where one or more columns are identifier variables (id_vars), while all other columns, considered measured variables (value_vars), are “unpivoted” to the row axis, leaving just two non-identifier columns, ‘variable’ and ‘value’.

And the parameters are:

Parameters

• id_vars : tuple, list, or ndarray, optional

  Column(s) to use as identifier variables.

• value_vars : tuple, list, or ndarray, optional

  Column(s) to unpivot. If not specified, uses all columns that are not set as id_vars.

• var_name : scalar

  Name to use for the ‘variable’ column. If None it uses frame.columns.name or ‘variable’.

• value_name : scalar, default ‘value’

  Name to use for the ‘value’ column.

• col_level : int or str, optional

  If columns are a MultiIndex then use this level to melt.

• ignore_index : bool, default True

  If True, original index is ignored. If False, the original index is retained. Index labels will be repeated as necessary.

  New in version 1.1.0.

Melting merges multiple columns and converts the dataframe from wide to long, for the solution to Problem 1 (see below), the steps are:

1. First we got the original dataframe.

2. Then the melt firstly merges the Math and English columns and makes the dataframe replicated (longer).

3. Then finally adds the column Subject which is the subject of the Grades columns value respectively.

This is the simple logic to what the melt function does.

I will solve my own questions.

Problem 1 could be solve using pd.DataFrame.melt with the following code:

I can't think of any way to add this logic on the DB. Would it be acceptable to manage these constraints in your code? Like this:

Event: a new image would be insterted in DB

What you are looking for is collision detection. When you move or resize your box you can check if the new dimensions/position does collide with other boxes. If that is the case then you can ignore the movement/resize.

Because your code snippet contained a lot of invalid HTML I had to strip most of it to make it work. Please do spend some time making valid HTML when/if you ask your next question. Some errors that were present in your HTML code:

• All content was made in the element
• Usage of HTML tags. Only certain tags can exist out of one tag like
is valid but is not and the proper way of writing some HTML tags like input is (without closing tag)
• Closing tags without any starting tags
• Closing parent tags before closing all the child tags