tackle | Collection of fish shell functions modules plugins

A Solution using the tidyverse:

Honestly, after days of research, I'm trying to talk the team into the idea of creating an API dedicated to Docs, and as part of that effort would migrate documents to AWS S3 or azure blob storage. We will introduce Aspose for rendering and separate the Issue.

Why? because all the solutions I have seen to support doc and Docx in .net5 are really hacky and I can see lacks in terms of security. And I would not recommend anyone to try to do the approach I was looking to do at the begging of this question.

I leave here what experience cause this research was pain and I hope this question can still help someone.

We needed the adress of t0

Registers don't have addresses: they have names; they have positions/index in the register file, and, they hold values.

Only memory has addresses.

Since, lw, does need the correct value of mem[$t0] + 4

That lw accesses mem[$t0+4], and it needs $t0's value so it can do the + .

The lw and sw instructions compute an effective address:

Screenshot below refers:

Google sheets here

IMPORTANT UPDATE: re: 2000+ rows, see link in my last comment (for OneDrive template, s.t. expiry, and bottom of this proposal for screenshot of error "too large to import")

fyi: (Office 365 - Excel - fns. such as 'filter' etc., so #Name! will be ubiquitous upon opening this link; however, sharing this should serve as a convenient means to replicate above screenshot in the correct version of Excel)

1. Office 365
2. Adequate space to the right or ability to utilise extra sheet for calcs as req.

High-level | Take-aways

• Relies on 2 additional tables: Qty 'depletion' table (here - G:P) and corresp. Profit Vectors (here - R:Z)

• Compressed representations (2x2 tables, per Summary Tables, here: rows 19:32) could be explored to simplify matters (albeit these are still Work in Progress ['WiP'])

• VB could be attractive alternative too

Low-level | Procedural

1. Single-cell function could not be found without exceptional complication (however, suspect it could be possible e.g. using FilterXML?)
2. Qty label transposes filtered negative quantities (grey shaded, G3: J3)
3. These values are depleted in turn (from left to right, i.e. dependency on having data sorted in ascending order by date (in this depiction, data first sorted by 'fruit' as these are assumed to be independent in the context of the profit calc.)
4. For example, -5 quantity (G3) offset by +10 (B3) to yield +5 which, in turn contributes towards the -35 qty (H3) to yield -30. No further contribution can be made (left to right); next row (5): +20 avail (given), no offset against -5 (G3, already 'reimbursed', so 20 offset against -30 (H4) to yield -10, and so forth.
5. Worksheet set up to accommodate longer list of fruit / profits
6. Result table of residual 'quantities' (~ G:J) applied to price differential to yield 'profit vectors' (R:U) which are summed against corresponding negative quantities to produce Profit score (yellow shaded cells)

Salient functions (all of which should be available within Google Sheet, but for completeness):

1) Profit calc. (E4, drag down):

You can use zoo::na.approx -

The SpaCy tokenizer seems to cache each token in a map internally. Consequently, each new token increases the size of that map. Over time, more and more new tokens inevitably occur (although with decreasing speed, following Zipf's law). At some point, after having processed large numbers of texts, the token map will thus outgrow the available memory. With a large amount of available memory, of course this can be delayed for a very long time.

The solution I have chosen is to store the SpaCy model in a TTLCache and to reload it every hour, emptying the token map. This adds some extra computational cost for reloading the SpaCy model from, but that is almost negligible.

This is clearly iterative code, not cascaded dependencies. Yes, use a loop.

If the column names text is 'white' and background 'red'

The keeping and processing of data should always be kept separate from the output. A Health class that processes inputs such as damage or healing can ensure that the minimum and maximum values are not exceeded. Last but not least, a render method can output the data in the desired form.

Edit: I changed the Health class from int to double so that the class can process floating point values. The render method now also accepts a length specification.

An example: