docs: update figma content with theme file deprecation change

Closes #3644
Updates content in various places on the website to reflect the deprecation of our Figma theme files.
*Note: Need to update various links to the "All themes" Figma file (previously known as White theme) once the file is published. It may change the URL name.

Changed
Content across these pages:

Designing > Get started page.
Designing > Design Kits (Figma tab) page.
Migrating > Guide page.
Migrating > Guide > Design tab page.

Removed

Some old images not being used.

Questions for Reviewers
Getting started > Design Kits (Figma tab) page:

Notice the placement of the notification. Is this in a good spot? Or should it be within the Internal and External section instructions?
Do we want to still mention somewhere the deprecation of the other themes on this page?

V10 kits

I realized we are making these same changes for v10 libraries, but our v10 website and next catalog are out of date with this information. Taylor said I will need to make a PR on the v10 branch to update those places.

Ahh. Good catch, thank you!! @aagonzales


map i_ctrl-] to noop

There are some plugins which use i_ctrl-] to expand abbreviations (like nvim-autopairs with enable_abbr = true, autoclose.nvim and ultimate-autopair.nvim). Until neovim introduces an API for expanding abbreviations, we can map i_ctrl-] to noop so that such plugins don't insert a character that the user didn't intend to insert.

I don't see any advantage in adding this. Right now there are other mappings that are not supported and we don't do anything about them either.
If this is anoying you could map it in your config.
 require('multicursors').setup {
    insert_keys = {
        ['<C-[>'] = {
            method = function() end,
        },
    },
}

So no then, okay.


[SPARK-29275][SQL][DOC] Describe special date/timestamp values in the SQL migration guide

What changes were proposed in this pull request?
Updated the SQL migration guide regarding to recently supported special date and timestamp values, see https://github.com/apache/spark/pull/25716 and https://github.com/apache/spark/pull/25708.
Closes #25834
Why are the changes needed?
To let users know about new feature in Spark 3.0.
Does this PR introduce any user-facing change?
No

Merged build finished. Test PASSed.

Test PASSed.
Refer to this link for build results (access rights to CI server needed):
https://amplab.cs.berkeley.edu/jenkins//job/SparkPullRequestBuilder-K8s/16510/
Test PASSed.

@cloud-fan Please, take a look at this.

Test build #111481 has started for PR 25948 at commit 5d8e57b.

Test build #111481 has finished for PR 25948 at commit 5d8e57b.

This patch passes all tests.
This patch merges cleanly.
This patch adds no public classes.

Merged build finished. Test PASSed.

Test PASSed.
Refer to this link for build results (access rights to CI server needed):
https://amplab.cs.berkeley.edu/jenkins//job/SparkPullRequestBuilder/111481/
Test PASSed.

Merged build finished. Test PASSed.

Test PASSed.
Refer to this link for build results (access rights to CI server needed):
https://amplab.cs.berkeley.edu/jenkins//job/SparkPullRequestBuilder-K8s/16516/
Test PASSed.

Test build #111491 has started for PR 25948 at commit c2c6d0c.

Test build #111491 has finished for PR 25948 at commit c2c6d0c.

This patch passes all tests.
This patch merges cleanly.
This patch adds no public classes.

Merged build finished. Test PASSed.

Test PASSed.
Refer to this link for build results (access rights to CI server needed):
https://amplab.cs.berkeley.edu/jenkins//job/SparkPullRequestBuilder/111491/
Test PASSed.

Merged to master. Thank you, @MaxGekk and @srowen !


Emails are unreadable in dark mode on Windows

I have tested the previews on the below configurations (using dark mode in Windows). Note: this also happens when I use my own (local) .html file.
Windows 10 Pro 1803

Google Chrome Version 94.0.4606.61 (Official Build) (64-bit)
Mozilla Firefox 92.0.1 (64-bit)

Windows 10 Pro 21H1

Google Chrome Version 94.0.4606.61 (Official Build) (64-bit)
Microsoft Edge Version 95.0.1020.5 (Official build) dev (64-bit)

Screenshot:

Thanks @darshanrampatel - I've fixed the issue now, feel free to retest.
It was caused by line breaks in the class attribute for some specific class names, and in the production configuration these were concatenated together without a space in between. I am not sure entirely why the line breaks were not replaced with a space as this is what should have happened.

@paul-oms thanks - they look much better now!


libsForQt5.mlt: 7.16.0 -> 7.18.0

Automatic update generated by nixpkgs-update tools. This update was made based on information from passthru.updateScript.
meta.description for libsForQt5.mlt is: Open source multimedia framework, designed for television broadcasting
meta.homepage for libsForQt5.mlt is: https://www.mltframework.org/
Updates performed

Ran passthru.UpdateScript

To inspect upstream changes

Release on GitHub

Compare changes on GitHub

Impact

Checks done (click to expand)

built on NixOS
The tests defined in passthru.tests, if any, passed
found 7.18.0 with grep in /nix/store/89y062z58jas890lvibayjsd7jddrmj6-mlt-7.18.0
found 7.18.0 in filename of file in /nix/store/89y062z58jas890lvibayjsd7jddrmj6-mlt-7.18.0

Rebuild report (if merged into master) (click to expand)

11 total rebuild path(s)

11 package rebuild(s)

First fifty rebuilds by attrpath
flowblade
hikounomizu
libsForQt5.kdenlive
libsForQt5.mlt
mlt
plasma5Packages.kdenlive
plasma5Packages.mlt
python310Packages.mlt
python311Packages.mlt
shotcut
synfigstudio

Instructions to test this update (click to expand)

Either download from Cachix:
nix-store -r /nix/store/89y062z58jas890lvibayjsd7jddrmj6-mlt-7.18.0 \
  --option binary-caches 'https://cache.nixos.org/ https://nix-community.cachix.org/' \
  --option trusted-public-keys '
  nix-community.cachix.org-1:mB9FSh9qf2dCimDSUo8Zy7bkq5CX+/rkCWyvRCYg3Fs=
  cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY=
  '

(The Cachix cache is only trusted for this store-path realization.)
For the Cachix download to work, your user must be in the trusted-users list or you can use sudo since root is effectively trusted.
Or, build yourself:
nix-build -A libsForQt5.mlt https://github.com/r-ryantm/nixpkgs/archive/a676b98bf0d5b3d76e2c38c3f02875a93b50e941.tar.gz

After you've downloaded or built it, look at the files and if there are any, run the binaries:
ls -la /nix/store/89y062z58jas890lvibayjsd7jddrmj6-mlt-7.18.0
ls -la /nix/store/89y062z58jas890lvibayjsd7jddrmj6-mlt-7.18.0/bin

Pre-merge build results
We have automatically built all packages that will get rebuilt due to
this change.
This gives evidence on whether the upgrade will break dependent packages.
Note sometimes packages show up as failed to build independent of the
change, simply because they are already broken on the target branch.
Result of nixpkgs-review run on x86_64-linux 1

1 package failed to build:

pixinsight

9 packages built:

flowblade
hikounomizu
libsForQt5.kdenlive
libsForQt5.mlt
mlt
python310Packages.mlt
python311Packages.mlt
shotcut
synfigstudio

Maintainer pings
cc @cillianderoiste for testing.

Result of nixpkgs-review pr 246374 run on aarch64-darwin 1

1 package marked as broken and skipped:

hikounomizu

8 packages built:

libsForQt5.mlt (plasma5Packages.mlt)
libsForQt5.mlt.dev (plasma5Packages.mlt.dev)
mlt
mlt.dev
python310Packages.mlt
python310Packages.mlt.dev
python311Packages.mlt
python311Packages.mlt.dev


Text replaces existing neighbouring text.

Description
When I Use Brackets and  I have some text for example this one.
Now when I place the cursor anywhere in the middle of the text it starts replacing the existing text(see the GIF).

Steps to Reproduce

[Enter any random text. It can be any text(even HTML).]
[Next Place the cursor in between the text and starting typing anything. ]
[You will see that the new text will replace the existing one.]

Expected behavior: [I expected that the text will be inserted in between the existing text and the existing text will not be affected]
Actual behavior: [The existing text was replaced by the new text(see the GIF).]
Versions
I am using windows 10
Brackets Version : Release 1.11 build 1.11.0-17524 (release 86b5e2d4e)

You are in the Overwrite mode, you can see it in the statusbar where there is the OVR label.
To go back in the Insert mode you can click it again or press the Ins button on your keyboard.


:construction: Worked on German translation of Tic-Tac-Toe Tutorial

#34
I worked a little bit on the Translation, might continue in the next couple of days and then proof-read it :)
Cheers

Hey folks,
I will review it on Saturday.
@liza-kl, thanks for your awesome efforts,
we really appreciate it!

Hey folks,
I will review it on Saturday.
@liza-kl, thanks for your awesome efforts,
we really appreciate it!

Hey @liza-kl,
hope you're doing well!
It would be cool to keep the ball rolling.
Please let us know if you are interested in having a look at this.
No hard feelings if you're not, just to know the current situation :slightly_smiling_face:.
Greetings
Michael

Guten Morgen,
ich würde bei der Vervollständigung etc. auch unterstützen wollen, bin aber (als seltener GitHub-Nutzer) etwas verwirrt, weil bei mir immer die Meldung kommt, dass ich mich nicht in einem Branch befinde. Falls ich helfen kann, lasst es mich gerne wissen.

Hey folks,
I just approved my own suggestions, so that we can finish this task.
@ph1p Can we ignore the missing Vercel deployment check?
@pop1989bb Sorry for missing your reply. You can simply create your own pull requests after this current pull request will be merged. Reach out if you need some help.
Greetings
Michael

Hmm the error on vercel is new to me, but I think we can merge the changes for now.
Looks good to me! 👍


ts-morph exception using PayPal OpenAPI spec

Describe the Bug
Failure when generating from public paypal OpenAPI specs.
# .... Lots of logs
Generating /src/serialization/types/SubscriptionsCreate422DetailsItem.ts
Sent error event to coordinator
/nodeCli.cjs:179343
            throw new common2.errors.NotImplementedError(`Unexpected! Inserting syntax kind of ${common2.getSyntaxKindName(expectedKind)}, but ${child.getKindName()} was inserted.`);
                  ^

NotImplementedError: Unexpected! Inserting syntax kind of InterfaceDeclaration, but ExpressionStatement was inserted.
    at getRangeWithoutCommentsFromArray (/nodeCli.cjs:179343:19)
    at insertIntoBracesOrSourceFileWithGetChildren (/nodeCli.cjs:180859:14)
    at ModuleDeclaration._insertChildren (/nodeCli.cjs:189483:18)
    at ModuleDeclaration.insertInterfaces (/nodeCli.cjs:189297:23)
    at ModuleDeclaration.addInterfaces (/nodeCli.cjs:189291:23)
    at ModuleDeclaration.addInterface (/nodeCli.cjs:189288:23)
    at _GeneratedUnionSchema.generateRawTypeDeclaration (/nodeCli.cjs:277148:34)
    at _GeneratedUnionSchema.generateModule (/nodeCli.cjs:277112:10)
    at _GeneratedUnionSchema.writeSchemaToFile (/nodeCli.cjs:277095:10)
    at _GeneratedUnionSchema.writeSchemaToFile (/nodeCli.cjs:277227:11)

Node.js v18.1.0

Seems to be related to some unexpected ts-morph invariant being broken, but I'm not sure.
Information to Reproduce
CLI Version
The version of the Fern CLI you are
using (found in fern.config.json).
Local build, latest commit https://github.com/fern-api/fern/commit/079a084cd98cb6f8e2a34bf784f71210cda32a4b
Generator Version
The version of the generator you are using (found in generators.yml). Plus any custom configuration required to reproduce the bug (found in generators.yml).
Bug happens on Typescript generators 0.13.0 / 0.15.0-rc0 / any I've tested
default-group: local
groups:
  local:
    generators:
      - name: fernapi/fern-typescript-node-sdk
        version: 0.13.0
        output:
          location: local-file-system
          path: ../generated/sdks/typescript

I also tried the Python generator, and it generated successfully.
API Definition
Here's the spec that causes the issue: https://github.com/paypal/paypal-rest-api-specifications/raw/main/openapi/billing_subscriptions_v1.json
I'm not sure what the minimal reproduction is unfortunately, I'm not even sure what causes the issue. However, running generate on this api should cause the issue pretty easily.
Actual SDK
The buggy SDK that is produced: N/A  (errors out)
Expected SDK
N/A
Additional Context
To reproduce, I'd just try the minimal init / generate from the above using --openapi, it should happen pretty easily.

Closing as stale. Now that the typescript generator version is 0.42.5, lots has changed since this report was filed.
If anyone runs into this and finds it to still be an issue, please let me know and I can re-open this issue.


Remove hard-coded viewsets

As here: https://github.com/acdh-oeaw/apis-core-rdf/blob/77b1ce33f2a677fc9a67e8a2debe59b3311f5ba4/apis_core/apis_entities/api_views.py#L126

closing as not up to date anymore.


get_pr_list "Attempt to decode a blank string"

require('ghlite').setup{}
:GHLitePRSelect

Error executing Lua callback: Vim:E474: Attempt to decode a blank string
stack traceback:
        [C]: in function 'parse'
        .../nvim/site/pack/paqs/start/ghlite.nvim/lua/ghlite/gh.lua:152: in function 'get_pr_list'
        ...e/pack/paqs/start/ghlite.nvim/lua/ghlite/pr_commands.lua:9: in function 'ui_selectPR'
        ...e/pack/paqs/start/ghlite.nvim/lua/ghlite/pr_commands.lua:32: in function <...e/pack/paqs/start/ghlite.nvim/lua/ghlite/pr_commands.lua:31>

Thanks for sharing your plugin. I've been looking for a minimal gh wrapper and I have hopes for this one :)

What gh pr list --json number,title,author,createdAt,isDraft,reviewDecision,headRefName,headRefOid,baseRefName returns when is executed from command line?

Oh, right :)
$ gh pr list --json number,title,author,createdAt,isDraft,reviewDecision,headRefName,headRefOid,baseRefName
HTTP 401: Bad credentials (https://api.github.com/graphql)
Try authenticating with:  gh auth login

I will need to handle scenarios like that somehow. At least user should know what has not worked.


Convert types and utilities to Kotlin

After this PR, almost no java files should be left. Only obsolete code which will be removed very soon should be left.
Files left:

[x] package de.fraunhofer.aisec.cpg.processing
[x] TriConsumer

I have added a newUnknownType function, the rest looks good. Merging now.


Kivy on BeagleBone Black error

Kivy was working fine on my Raspberry Pi running Raspian. I have been trying to run Kivy on BeagleBone running Debian Jessie. I installed according to the directions for Jessie in the docs. I get this error:
[INFO   ] [Logger      ] Record log in /root/.kivy/logs/kivy_16-04-06_5.txt
[INFO   ] [Kivy        ] v1.9.1
[INFO   ] [Python      ] v2.7.9 (default, Mar  1 2015, 13:48:22)
[GCC 4.9.2]
[INFO   ] [Factory     ] 179 symbols loaded
[INFO   ] [Image       ] Providers: img_tex, img_dds, img_gif, img_sdl2, img_pil (img_ffpyplayer ignored)
[INFO   ] [Text        ] Provider: sdl2
[INFO   ] [OSC         ] using  for socket
[INFO   ] [Window      ] Provider: sdl2(['window_egl_rpi'] ignored)
error: XDG_RUNTIME_DIR not set in the environment.
[CRITICAL] [Window      ] Unable to find any valuable Window provider at all!
egl_rpi - ImportError: cannot import name bcm
File "/usr/lib/python2.7/dist-packages/kivy/core/init.py", line 59, in core_select_lib
fromlist=[modulename], level=0)
File "/usr/lib/python2.7/dist-packages/kivy/core/window/window_egl_rpi.py", line 12, in
from kivy.lib.vidcore_lite import bcm, egl
sdl2 - RuntimeError: No available video device
File "/usr/lib/python2.7/dist-packages/kivy/core/init.py", line 67, in core_select_lib
cls = cls()
File "/usr/lib/python2.7/dist-packages/kivy/core/window/window_sdl2.py", line 138, in init
super(WindowSDL, self).init()
File "/usr/lib/python2.7/dist-packages/kivy/core/window/init.py", line 722, in init
self.create_window()
File "/usr/lib/python2.7/dist-packages/kivy/core/window/window_sdl2.py", line 237, in create_window
self.fullscreen, resizable, state)
File "_window_sdl2.pyx", line 80, in kivy.core.window._window_sdl2._WindowSDL2Storage.setup_window (kivy/core/window/_window_sdl2.c:1810)
File "_window_sdl2.pyx", line 55, in kivy.core.window._window_sdl2._WindowSDL2Storage.die (kivy/core/window/_window_sdl2.c:1460)
x11 - ImportError: No module named window_x11
File "/usr/lib/python2.7/dist-packages/kivy/core/init.py", line 59, in core_select_lib
fromlist=[modulename], level=0)
[CRITICAL] [App         ] Unable to get a Window, abort.

You might try looking at this forum post: https://groups.google.com/forum/#!topic/beagleboard/tsRfbDVwjSM
However, note that this is a known issue with BBB: beagleboard/linux#31
You can find other similar stories by searching Google for "beaglebone black sdl2" or "beaglebone black opengl".
If you can get it working, great! But BBB is not an officially supported platform for Kivy.


evalution error occurred!

After all the twists and turns, the training went well. Now when I try to evaluate, I get a failure message. What should I do?
The files appearing in the error message exist and it is possible to open the file. But why does this happen?
[2021-08-22 21:29:24,641] smoke.data.datasets.evaluation.kitti.kitti_eval INFO: Evaluate on KITTI dataset
[2021-08-22 21:29:24,726] smoke.data.datasets.evaluation.kitti.kitti_eval INFO: Thank you for participating in our evaluation!
Loading detections...
number of files for evaluation: 7518
ERROR: Couldn't read: 002501.txt of ground truth. Please write me an email!
An error occured while processing your results.

Hi all,
I also having the same issue here
number of files for evaluation: 3769 ERROR: Couldn't read: 006434.txt of ground truth. Please write me an email! An error occured while processing your results.
does anyone know the solution? thank you in advance.


Overaggressive Parsing

After instantiation, the parser is unable to use variables beginning with "for", "while", and "if" as it mistakes them for the corresponding language statements.  Variables beginning with "in", "repeat", "until", "then", "else", "true", and "false" seem to parse fine.

Can this be closed? I assume this was fixed but never closed.

@jgagry is right --- it was fixed, but never closed.


[subset] feature request: add support for subsetting variable COLRv1 table

all the unused VarIdxes need to be pruned from the VarStore after subsetting glyphs, and the remaining ones remapped, similarly to how we do with variable GPOS

Remapping is harder for COLRv1 since the paints use consecutive VarIdx'es.


Navigation BACK Button not working in Hybrid Mode

I love the idea here having the HybridOnNavigation option.   I found an issue that when I am navigating from one page to another in the  Hybrid mode, if I hit the BACK button which is very typical of users, the page didn't redraw.  In Server mode or WebAssembly mode, the back buttons worked as expected.
With .Net 6, I did have issues with the HeadOutlet for HybridManual, or HybridOnReady.  For WebAssembly or HybridOnNavigation, I created a workaround.  As you can see, I had to comment out the HybridManual.
HybridTypeEnum? hybridType = null;
try
{
    hybridType = await httpClient.GetFromJsonAsync<HybridTypeEnum>("/api/hybridtype");
}
catch { }

hybridType ??= HybridTypeEnum.WebAssembly;

switch (hybridType)
{
    case HybridTypeEnum.WebAssembly:
    case HybridTypeEnum.WebAssemblyPreRendered:
        builder.RootComponents.Add<App>("#app");
        builder.RootComponents.Add<HeadOutlet>("head::after");
        break;
    case HybridTypeEnum.HybridOnNavigation:
        builder.RootComponents.Add<HeadOutlet>("head::after");
        break;
    case HybridTypeEnum.HybridManual:
        //builder.RootComponents.Add<HeadOutlet>("head::after");
        break;
    default:

        break;
}

FYI... I recreated the IdentityServer pages as razor components, working with Server, WebAssembly, WebAssemblyPreRendered, and HybridOnNavigation, and it works with Login Providers such as Facebook, Twitter, and Google.  It works very well with very little configuration.   The only time you leave your environment is when you authenticate with a remote provider.  I haven't quite figured out the backend workings of Microsoft.Identity.Web, so I don't think it is quite ready to release as a NuGet, but I might put it on GitHub.

Hello, thank you for your interest in the project and for the information about the findings. I tried to reproduce the problem with navigation but could not, the back button works for me (checked Chrome, Firefox). Have you used the latest version of the code? I just fixed a problem with navigation a month ago.

Gif
![Animation](https://user-images.githubusercontent.com/47177226/163042441-cde5d85f-f18e-427c-ac4d-8348466f7a32.gif)

I haven't tried HeadOutlet yet, but I'll take a look, thanks.
Of course post your project on github, it will be interesting to see the implementation


In strict mode, bail on finding temporal words

In strict mode, when we know we don't specially handle certain temporal words (like december), better to to not continue processing.

Thanks!


Specialization of standard posits

Since the latest standard for posits (https://github.com/posit-standard/Posit-Standard-Community-Feedback) fixes the exponent size to 2 bits, it would be desirable to have fast specialization of posit types with 2 exponent bits (at least, 8, 16, 32, and even 64 bits) for performance in software experimentation.
I don't know how difficult it would be to adapt the current specialized/posit_8_0.hpp and specialized/posit_16_1.hpp (specialized/posit_32_2.hpp will be the same I guess) to the new standard.

Would you be able to drive this development?

Sure! As far as I know, it should resemble previous specialized implementations, with adjustments to the parameters and arithmetic operations for those specific formats. Am I right?
Also, could you please point me to some regression tests to ensure that the specialized implementations provide the same functionality as the default ones?

I can set up the regression tests for the standard specialized posits so
you can focus on the implementation
On Fri, Jun 2, 2023, 19:06 Raul Murillo Montero @.***>
wrote:

Would you be able to drive this development?
Sure! As far as I know, it should resemble previous specialized
implementations, with adjustments to the parameters and arithmetic
operations for those specific formats. Am I right?
Also, could you please point me to some regression tests to ensure that
the specialized implementations provide the same functionality as the
default ones?
—
Reply to this email directly, view it on GitHub
https://github.com/stillwater-sc/universal/issues/343#issuecomment-1574419943,
or unsubscribe
https://github.com/notifications/unsubscribe-auth/AZZNV3GFI4XZEC4L4Z6PFGTXJJWWPANCNFSM6AAAAAAYX744L4
.
You are receiving this because you commented.Message ID:
@.***>

@RaulMurillo I have created a branch 'fast_specialized_posit', and enabled the fast posit path in the regressions. I put a skeleton together for posit<16,2> and that yielded this:
Fast specialization posit<16,2> configuration tests
 posit< 16,2> useed scale     4     minpos scale        -56     maxpos scale         56  :  0

Special case tests
posit< 16, 2> Initialize to zero:            PASS
posit< 16, 2> Initialize to NAN              PASS
posit< 16, 2> Initialize to INFINITY         PASS
posit< 16, 2> sign is true                   PASS
posit< 16, 2> is negative                    PASS
posit< 16, 2> sign is false                  PASS
posit< 16, 2> is positive                    PASS
posit< 16, 2>                                                addition       PASS
posit< 16, 2>                                                subtraction    PASS
posit< 16, 2>                                                multiplication PASS
posit< 16, 2>                                                division       PASS

For REGRESSION_LEVEL_1. Levels 2, 3, and 4 will add logic, randoms, and the math library to the mix. I also enabled it in the CI, so any check-ins against that branch will automatically run the regression suite.
I can show you how to work with the REGRESSION levels and the manual test regression infrastructure.
The 32bit and 64bit posits are much more difficult to validate as the native double and long doubles are not sufficiently precise to serve as reference. I have not weighed down the regression suite with a high-precision reference as it would make the regression suites run too slowly. For 32bit and 64bit regression testing we should do one of two things:
1- create a judicious direct testing suite to target specific corner cases so that we are fast and light weight
2- create a double-double reference type for 32-bit randoms, and double-double-double reference type for 64-bit randoms
A third option is to complete the Priest arithmetic type that I started as an adaptive precision Oracle that still has hardware support and thus will run quick enough not to weight down the CI regression cycle.

This is what you should see when you build with cmake -DBUILD_NUMBER_POSITS=ON ..
1>Test project C:/Users/tomtz/Documents/dev/clones/universal/build
1>      Start  1: posit_api
1> 1/59 Test  #1: posit_api ........................   Passed    0.04 sec
1>      Start  2: posit_casting
1> 2/59 Test  #2: posit_casting ....................   Passed    0.04 sec
1>      Start  3: posit_constexpr_test
1> 3/59 Test  #3: posit_constexpr_test .............   Passed    0.03 sec
1>      Start  4: posit_decode
1> 4/59 Test  #4: posit_decode .....................   Passed    0.03 sec
1>      Start  5: posit_number_traits
1> 5/59 Test  #5: posit_number_traits ..............   Passed    0.04 sec
1>      Start  6: posit_postfix
1> 6/59 Test  #6: posit_postfix ....................   Passed    0.04 sec
1>      Start  7: posit_prefix
1> 7/59 Test  #7: posit_prefix .....................   Passed    0.03 sec
1>      Start  8: posit_quire_accumulation
1> 8/59 Test  #8: posit_quire_accumulation .........   Passed    0.04 sec
1>      Start  9: posit_reciprocal_tables
1> 9/59 Test  #9: posit_reciprocal_tables ..........   Passed    0.03 sec
1>      Start 10: posit_serialization
1>10/59 Test #10: posit_serialization ..............   Passed    0.03 sec
1>      Start 11: posit_ulp
1>11/59 Test #11: posit_ulp ........................   Passed    0.03 sec
1>      Start 12: posit_assignment
1>12/59 Test #12: posit_assignment .................   Passed    0.03 sec
1>      Start 13: posit_conversion
1>13/59 Test #13: posit_conversion .................   Passed    0.04 sec
1>      Start 14: posit_logic
1>14/59 Test #14: posit_logic ......................   Passed    0.26 sec
1>      Start 15: posit_addition
1>15/59 Test #15: posit_addition ...................   Passed    1.42 sec
1>      Start 16: posit_complex_add
1>16/59 Test #16: posit_complex_add ................   Passed    0.15 sec
1>      Start 17: posit_decrement
1>17/59 Test #17: posit_decrement ..................   Passed    0.03 sec
1>      Start 18: posit_division
1>18/59 Test #18: posit_division ...................   Passed    0.54 sec
1>      Start 19: posit_fma
1>19/59 Test #19: posit_fma ........................   Passed    0.03 sec
1>      Start 20: posit_increment
1>20/59 Test #20: posit_increment ..................   Passed    0.03 sec
1>      Start 21: posit_literals
1>21/59 Test #21: posit_literals ...................   Passed    0.43 sec
1>      Start 22: posit_multiplication
1>22/59 Test #22: posit_multiplication .............   Passed    0.36 sec
1>      Start 23: posit_negation
1>23/59 Test #23: posit_negation ...................   Passed    0.08 sec
1>      Start 24: posit_reciprocation
1>24/59 Test #24: posit_reciprocation ..............   Passed    0.03 sec
1>      Start 25: posit_sqrt
1>25/59 Test #25: posit_sqrt .......................   Passed    0.16 sec
1>      Start 26: posit_subtraction
1>26/59 Test #26: posit_subtraction ................   Passed    0.34 sec
1>      Start 27: posit_classify
1>27/59 Test #27: posit_classify ...................   Passed    0.04 sec
1>      Start 28: posit_complex
1>28/59 Test #28: posit_complex ....................   Passed    0.03 sec
1>      Start 29: posit_exponent
1>29/59 Test #29: posit_exponent ...................   Passed    0.50 sec
1>      Start 30: posit_hyperbolic
1>30/59 Test #30: posit_hyperbolic .................   Passed    0.05 sec
1>      Start 31: posit_hypotenuse
1>31/59 Test #31: posit_hypotenuse .................   Passed    0.03 sec
1>      Start 32: posit_logarithm
1>32/59 Test #32: posit_logarithm ..................   Passed    0.03 sec
1>      Start 33: posit_next
1>33/59 Test #33: posit_next .......................   Passed    0.03 sec
1>      Start 34: posit_pow
1>34/59 Test #34: posit_pow ........................   Passed    0.12 sec
1>      Start 35: posit_trigonometry
1>35/59 Test #35: posit_trigonometry ...............   Passed    0.03 sec
1>      Start 36: posit_truncate
1>36/59 Test #36: posit_truncate ...................   Passed    0.03 sec
1>      Start 37: fast_posit_128_2
1>37/59 Test #37: fast_posit_128_2 .................   Passed    0.34 sec
1>      Start 38: fast_posit_128_4
1>38/59 Test #38: fast_posit_128_4 .................   Passed    0.31 sec
1>      Start 39: fast_posit_16_1
1>39/59 Test #39: fast_posit_16_1 ..................   Passed    0.03 sec
1>      Start 40: fast_posit_16_2
1>40/59 Test #40: fast_posit_16_2 ..................   Passed    0.03 sec
1>      Start 41: fast_posit_256_2
1>41/59 Test #41: fast_posit_256_2 .................   Passed    1.11 sec
1>      Start 42: fast_posit_256_5
1>42/59 Test #42: fast_posit_256_5 .................   Passed    1.06 sec
1>      Start 43: fast_posit_2_0
1>43/59 Test #43: fast_posit_2_0 ...................   Passed    0.03 sec
1>      Start 44: fast_posit_32_2
1>44/59 Test #44: fast_posit_32_2 ..................   Passed    0.07 sec
1>      Start 45: fast_posit_3_0
1>45/59 Test #45: fast_posit_3_0 ...................   Passed    0.03 sec
1>      Start 46: fast_posit_48_2
1>46/59 Test #46: fast_posit_48_2 ..................   Passed    0.11 sec
1>      Start 47: fast_posit_4_0
1>47/59 Test #47: fast_posit_4_0 ...................   Passed    0.04 sec
1>      Start 48: fast_posit_64_2
1>48/59 Test #48: fast_posit_64_2 ..................   Passed    0.16 sec
1>      Start 49: fast_posit_64_3
1>49/59 Test #49: fast_posit_64_3 ..................   Passed    0.16 sec
1>      Start 50: fast_posit_8_0
1>50/59 Test #50: fast_posit_8_0 ...................   Passed    0.05 sec
1>      Start 51: fast_posit_8_1
1>51/59 Test #51: fast_posit_8_1 ...................   Passed    0.33 sec
1>      Start 52: fast_posit_8_2
1>52/59 Test #52: fast_posit_8_2 ...................   Passed    0.29 sec
1>      Start 53: fast_quire_32_2
1>53/59 Test #53: fast_quire_32_2 ..................   Passed    1.99 sec
1>      Start 54: posit2_api
1>54/59 Test #54: posit2_api .......................   Passed    0.03 sec
1>      Start 55: posit2_attributes
1>55/59 Test #55: posit2_attributes ................   Passed    0.03 sec
1>      Start 56: posit2_manipulators
1>56/59 Test #56: posit2_manipulators ..............   Passed    0.03 sec
1>      Start 57: posit2_traits
1>57/59 Test #57: posit2_traits ....................   Passed    0.03 sec
1>      Start 58: posit2_ulp
1>58/59 Test #58: posit2_ulp .......................   Passed    0.03 sec
1>      Start 59: posit2_addition
1>59/59 Test #59: posit2_addition ..................   Passed    0.38 sec
1>
1>100% tests passed, 0 tests failed out of 59

fast specialized posit<64,2> is stubbed out as we need to figure out how to properly regress test this.

Thank you Theo!
I will start working on this. Meanwhile, we should define how to validate such datatypes.
What is this Priest arithmetic format you are talking about?

@RaulMurillo https://www.semanticscholar.org/paper/Algorithms-for-arbitrary-precision-floating-point-Priest/93e08bcc5581478bf109c22e68b84cf08e4d7354
I started this work but ran into a problem reproducing the paper's results. Need to find a brother in arms to RCA the problem and get over the hump.

@RaulMurillo if you look at the regression suite for posits in UNIVERSAL_ROOT/include/universal/verification/posit_test_suite.hpp
you will find a test called VerifyConversion. This test uses the inductive property that posit<nbits+1, es> with the last bit set falling exactly in the middle of two posit<nbits,es> values. So we can test all the rounding cases for an arbitrary posit by using this property and adding/keeping/subtracting a delta to the higher posit to generate the round-up, tie to even, and round-down values.
One idea for a quick regression test is to visit all (and just) the encodings where the rounding decision is going to rejigger the regime, and use this property to generate the golden reference.
For 32bit posits we would need to sit on a system that has proper long doubles, but for 64bit posits we need at least a triple-double reference arithmetic.
That would be a lovely addition to Universal, to have David Bailey's double-double, quad-double, and add a triple-double arithmetic type so that the lib has a fast Oracle number system for these types of verifications. Douglas Priest would be the adaptive precision Oracle for arbitrary precision questions.

@RaulMurillo also don't forget that there is a method: setbits(uint64_t) that allows you to set the posit to arbitrary bits. With the patterns suggested above we would have a super quick sanity test of only 64 tests in the case of posit<32,2> and 128 test cases for a posit<64,2>.
When the rounding doesn't change the field configuration, the rounding algorithm is 'invariant' across the field configurations, so no need to test all these cases when you have proven that one works. But when the rounding changes the field configuration the rounding needs to be verified.

@RaulMurillo how is this task going? Do you need any help?

Hi @Ravenwater , I'm sorry but I've been very busy during these days (and the following days I will be too) with the end of the course. I think I won't be able to dedicate myself to this for a few weeks, but when I have progress on this I'll let you know. If you want to make progress on this, go ahead, I don't want to be a bother in this task.

@RaulMurillo thanks for the update. I am currently focused on logarithmic number systems, so I was happy to delegate the task, :-) When you get time, the posit community will thank you.
I am working on Priest and faithfully rounded number systems to try to solve the validation problem of big posits. But that is adjacent, so won't get in the way.

I see that in #384 part of this has been merged. What is the status of these specializations? I'm specially interested in the Posit16 case in case it is incomplete. Thanks!

Can you share the failures that you are seeing in the specialized posit<16,2>?
If you want to fix/extend these specialized implementations, the architecture is that of a standard template specialization for the specific template arguments, in this case nbits = 16 and es = 2. The code you have found is exactly the code for that posit<16,2> specialization.
The functionality is always in a single include file, in this case, https://github.com/stillwater-sc/universal/blob/main/include/universal/number/posit/specialized/posit_16_2.hpp. Then there are the regression tests. For posits, you can find these here: https://github.com/stillwater-sc/universal/tree/main/static/posit/specialized
When you find the incorrect behavior, you can try to fix it and add regression tests to posit_16_2.cpp so that we close the hole.

Unfortunately I cannot share the application I'm running, but it is quite large and I haven't pinned exactly when/how it fails. In any case, it seems a generalized/common output error because I'm getting practically random output results.
To fix this I think it would be better to run and check the regression tests. Could you point me to how I can build and run the tests taht you mention in https://github.com/stillwater-sc/universal/tree/main/static/posit/specialized ? I can't seem to find any documentation on that. The CMakeLists in that directory doesn't make much sense to me and I guess there is another top-level one.

The CMake you want to look at is the top level in the root.
The build of Universal allows you to enable and disable specific sets of tests. If you just want to run the posit tests, issue the following cmake configuration commands:
mkdir build
cd build
cmake -DBUILD_NUMBER_POSIT=ON -DBUILD_DEMONSTRATION=OFF ..

now you will have all the posit regression tests enabled, and nothing else. Simple make and make test will then build and run the regression tests.
The specialized posit_16_2 regression test executable will sit in the build directory under specialized, so when you modify the posit_16_2.cpp, and rebuild, you can focus your testing on just that executable, much quicker than constantly running the full regression suite.

Perfect. I will try this and see if I can fix it. Thanks @theo-lemurian !

@davidmallasen I had a typo in the cmake command line, which I have fixed in the message above.

 However, the output seems to be all pass:
Fast specialization posit<16,2> configuration tests
 posit< 16,2> useed scale     4     minpos scale        -56     maxpos scale         56  :  0

Special case tests
posit< 16, 2> Initialize to zero:            PASS
posit< 16, 2> Initialize to NAN              PASS
posit< 16, 2> Initialize to INFINITY         PASS
posit< 16, 2> sign is true                   PASS
posit< 16, 2> is negative                    PASS
posit< 16, 2> sign is false                  PASS
posit< 16, 2> is positive                    PASS
posit< 16, 2>                                                addition       PASS
posit< 16, 2>                                                subtraction    PASS
posit< 16, 2>                                                multiplication PASS
posit< 16, 2>                                                division       PASS
Logic operator tests
posit< 16, 2>                                                    ==         (native)   PASS
posit< 16, 2>                                                    !=         (native)   PASS
posit< 16, 2>                                                    <          (native)   PASS
posit< 16, 2>                                                    <=         (native)   PASS
posit< 16, 2>                                                    >          (native)   PASS
posit< 16, 2>                                                    >=         (native)   PASS
Assignment/conversion tests
posit< 16, 2>                                                integer assign (native)   PASS
Arithmetic tests 1048576 randoms each
posit< 16, 2>                                                addition       (native)   PASS
posit< 16, 2>                                                +=             (native)   PASS
posit< 16, 2>                                                subtraction    (native)   PASS
posit< 16, 2>                                                -=             (native)   PASS
posit< 16, 2>                                                multiplication (native)   PASS
posit< 16, 2>                                                *=             (native)   PASS
posit< 16, 2>                                                division       (native)   PASS
posit< 16, 2>                                                /=             (native)   PASS
Elementary function tests
posit< 16, 2>                                                sqrt           (native)   PASS
posit< 16, 2>                                                exp                       PASS
posit< 16, 2>                                                exp2                      PASS
posit< 16, 2>                                                log                       PASS
posit< 16, 2>                                                log2                      PASS
posit< 16, 2>                                                log10                     PASS
posit< 16, 2>                                                sin                       PASS
posit< 16, 2>                                                cos                       PASS
posit< 16, 2>                                                tan                       PASS
posit< 16, 2>                                                asin                      PASS
posit< 16, 2>                                                acos                      PASS
posit< 16, 2>                                                atan                      PASS
posit< 16, 2>                                                sinh                      PASS
posit< 16, 2>                                                cosh                      PASS
posit< 16, 2>                                                tanh                      PASS
posit< 16, 2>                                                asinh                     PASS
posit< 16, 2>                                                acosh                     PASS
posit< 16, 2>                                                atanh                     PASS
VerifyPower has been truncated
posit< 16, 2>                                                pow                       PASS

I'm in the main branch with commit hash 92d08344. The specialized posit32 does work properly for me with the -DPOSIT_FAST_POSIT_32_2 compile flag. But the same for posit16 with the -DPOSIT_FAST_POSIT_16_2 flag doesn't. I've triple-checked that this is the only difference. Could it be that the stress tests are not up to date?

The regression tests are the same and up to date for general and specialized, we just swap out the arithmetic type.
Given that the bit pattern checks are passing for both general and specialized arithmetic, I assume that the arithmetic type is tested.
I am wondering if we have a specific problem with the storage format. A posit32 fits nicely in a standard unsigned int, but a posit16 needs to sit in an uint16_t. If we aggregate that in vectors and matrices, we need to be certain that the compiler environment doesn't straddle past the uint16_t.
Are there analytical test cases in your application that we can use to test memory alignment is honored?

@davidmallasen got some new info. As you know the posit<16,2> arithmetic tests exhaustively trace 4B combinations. To make these regressions complete in a reasonable time I use randoms just to quickly sample the state space and pick up obvious failures.
I modified the regression test to do an exhaustive enumeration of the state space and this popped out:
Fast specialization posit<16,2> configuration tests
 posit< 16,2> useed scale     4     minpos scale        -56     maxpos scale         56  :  0

Special case tests
posit< 16, 2> Initialize to zero:            PASS
posit< 16, 2> Initialize to NAN              PASS
posit< 16, 2> Initialize to INFINITY         PASS
posit< 16, 2> sign is true                   PASS
posit< 16, 2> is negative                    PASS
posit< 16, 2> sign is false                  PASS
posit< 16, 2> is positive                    PASS
Arithmetic tests
posit< 16, 2>                                                add            (native)   PASS
posit< 16, 2>                                                subtract       (native)   PASS
posit< 16, 2>                                                multiply       (native)   PASS
posit< 16, 2>                                                divide         (native)   PASS
posit< 16, 2>                                                negate         (native)   PASS
Uncaught posit arithmetic exception: posit arithmetic exception: divide by zero

The specialized versions appear not to have the same exception behavior as the general version.
Can you think of a mechanism that you can use in your app to catch different exceptions?
 I went through all the history of this issue that @RaulMurillo started. Raul offered to do the implementation as the posit<16,2> is now the standard, and I had implemented the posit<16,1> of the previous standard. I created the posit<16,2> file and regression test and was dependent on Raul to do the implementation. The specialized posit<16,2> is a verbatim copy of the posit<16,1> except for the template parameters.
What we are seeing is the result of the specialized posit<16,2> actually implementing a posit<16,1> behavior. The way the regression tests are written is that I enumerate the bit encodings, derive the double floating-point value, do a reference computation with the double values, then use the double to posit conversion to create the golden value, and then do the posit operation natively and compare the result to the golden value. So if the type implements any of these consistently, which in our case is doing it as a posit<16,1>, the regression test will pass.
Ok, so the solution is now known: we need to implement the specialized posit<16,2>.

Hello @Ravenwater . Thank! This makes sense now, although I have a couple of comments:

In the VerifyBinaryOperatorThroughRandoms function that I see is used in the tests, I see these two lines:
https://github.com/stillwater-sc/universal/blob/408b099b516e7d6f20b33dafc4936a6026426d64/include/universal/verification/posit_test_randoms.hpp#L273-L274
Doesn't this mean that the code is never going to enter the if statement (aka, it's never going to fail)? I guess the solution would be to remove the first assignment which overrides what is being computed as the result to test.

How is it correctly implementing a posit<16,1> behavior if at the begiining of the specialized/posit_16_2.hpp the ES_IS_2 is used? Is it replacing the posit<16,2> name with the template and implementing it as if it were a posit<16,2>?

In the case of testing the specialized posits, could it be possible to compare them directly to the computations done by the generic posit implementation that we know to be working properly? I guess this would be simpler as only the bit patterns would need to be checked to see that they are equal.

I'll work on trying to change the specialized/posit_16_2.hpp from implementing the specialized posit<16,1> to the proper posit<16,2>.

Also @Ravenwater do you have any documentation on the algorithm and notation you are following here? It differs from what I'm used to (I follow the scheme in section II-A of out PERCIVAL paper).

@davidmallasen

Dang, thanks for finding that bug. I vaguely remember that I was trying to implement posit<40,2> and posit<48,2> as our application profiling showed these posits are good replacements for IEEE-754 doubles typically providing slightly more precision. Trying to verify these posits we were pressed that we need an Oracle precision to follow our particular testing strategy as even long double does not carry enough precision to cover the rounding cases of these posits. I put that line #273 in to shut the regression failures up but then forgot about it. I'll need to do some restructuring to get that back on the rails.
Tracked the division by zero to reciprocal(). I need to just close the hole in that code path.
the subtlety here is that the template specialization is just to select the specialized code of choice. The posit<16,2> specialized code is not any template parameters, it is all hardcoded for speed. Since that hardcoded code is doing a posit<16,1> functionally, it is all consistent, wrong, but consistent.
I thought about that, but the specialization cuts you off from the generic. But we can just add another copy with a slightly different name and bring it in like that. I have wanted that functionality so often, this is the time, we should do it.

I also started to try to fix the posit<16,2>. I am working in the v3.74 branch. I can go and focus on the bugs you have just highlighted, and you can maybe finish the posit<16,2> implementation.

@davidmallasen the specialized posits are following the softposit algorithms with the proper C++ skeleton around it to create a plug-in type.

@davidmallasen this commit is a new baseline to work from: https://github.com/stillwater-sc/universal/commit/cac65dca3dd535dcbe9573ecf88b4e1d507ef05c

In this commit: https://github.com/stillwater-sc/universal/commit/025e51f4961e47bb6103906b751840a073b252d3 I have added a posito, short for posit oracle that we can use to RCA the specialized posit failures.

@davidmallasen correct, just the specialized posit<32,2>. I'll look at the commit history on that file to see when it changed and see if it has a quick fix.

@Ravenwater I don't understand the rationale behind changing the 2to a 3 in https://github.com/stillwater-sc/universal/blob/025e51f4961e47bb6103906b751840a073b252d3/include/universal/number/posit/specialized/posit_16_2.hpp#L676 . Isn't this function doing the same as decode_regime except for the different shift parameter (m)? I looked at the code in softposit, but there are no comments there to help guide what is going on.

I am postulating here, but the algorithm that John and Cerlane developed accumulates the fraction bits and leaves the MSB set to 0 as not to trigger any signed/unsigned reinterpretation. As the exponent field is now potentially 2 bits, we need to shift away the exponent field by adding one more to the left shift. One problem that I haven't reverse engineered is how they are dealing with the situation when the encoding doesn't have a full exponent field, like, 0b0.000'0000'0000'001.0   Maybe it is just as simple as the fact that if you don't have enough bits for a full exponent, your fraction bits are zero too, and thus 'over shifting' does not matter.

P.S. commit https://github.com/stillwater-sc/universal/commit/fb0d0ed0752a8785ba3403ec436791b897899c96 contains an addition test case that brings in both posit and posito to compare specialized and generalized implementations.

I am postulating here, but the algorithm that John and Cerlane developed accumulates the fraction bits and leaves the MSB set to 0 as not to trigger any signed/unsigned reinterpretation. As the exponent field is now potentially 2 bits, we need to shift away the exponent field by adding one more to the left shift.

The exponent field is after the regime, and in that function we are basically extracting the regime and returning the remaining bits (exponent and fraction), so this shouldn't be taken into account here? It is the same as in the decode_regime. If we want to remove the exponent, that should be done as what you added with remaining <<= 3; remaining >>= 2;. If not the function could not work if the regime is only 2 bits (I haven't tested this for all the regime-length patterns though).

One problem that I haven't reverse engineered is how they are dealing with the situation when the encoding doesn't have a full exponent field, like, 0b0.000'0000'0000'001.0 Maybe it is just as simple as the fact that if you don't have enough bits for a full exponent, your fraction bits are zero too, and thus 'over shifting' does not matter.

Since the values of the bits that are to the right of the LSB should be zero, I think this is accomplished when doing the shifts?
I will pull and check that new commit, thanks

I just realized that Softposit has a positX_2 code that could help us! I'll continue tomorrow looking at this. https://gitlab.com/cerlane/SoftPosit/-/blob/master/source/s_addMagsPX2.c

I got the add for positive values working, but we need the subtraction routine to work as well.
I also restructured quite a bit of the regression tests across all the number systems, so quite a few files have changed.
If you have time tomorrow, @davidmallasen take a look at operator-=() and see how that works.

Ah this makes sense @Ravenwater . I didn't realize that when adding two numbers with different signs, it's calling the -= operator and I didn't change that one. I'll have a look at it.

Could you have a look at #404 @Ravenwater ? I think with this we could try all the exhaustive testing on the specialized posit<16,2> with the oracle posit<16,2> since the rest of the operations should be correct. I'm not sure about the integer_assign and the float_assign helper functions though.

@davidmallasen I got the regime and exponent field algorithms figured out, but I haven't been able to understand the rounding algorithm that SoftPosit implements. I checked in the code as I need a second pair of eyes on this to try to figure out how this is supposed to work.
Here is the results of the regression tests fast_posit_16_2:
Fast specialization posit<16,2>: results only
 posit< 16,2> useed scale     4     minpos scale        -56     maxpos scale         56  :  0

posit< 16, 2>                                                +=             (native)   PASS
posit< 16, 2>                                                -=             (native)   PASS
posit< 16, 2>                                                *=             (native)   PASS
FAIL
-13.62890625              /= -0.443115234375           != 30.765625                 golden reference is 30.75

0b<IP_ADDRESS>10100001     /= 0b<IP_ADDRESS>00101110     != 0b<IP_ADDRESS>0110001     golden reference is 0b<IP_ADDRESS>0110000
FAIL
124.1875                  /= 0.0001163482666015625     != 1081344                   golden reference is 1064960

0b<IP_ADDRESS>1000011     /= 0b0.00001.10.11101000     != 0b0.1111110.00.000010     golden reference is 0b0.1111110.00.000001
FAIL
-0.004791259765625        /= 0.2958984375              != -0.016204833984375        golden reference is -0.0161895751953125
0b<IP_ADDRESS>1101000     /= 0b<IP_ADDRESS>01111000     != 0b<IP_ADDRESS>0100110     golden reference is 0b<IP_ADDRESS>0100101
FAIL
-0.443359375              /= 0.005786895751953125      != -76.5625                  golden reference is -76.625

0b<IP_ADDRESS>00110000     /= 0b<IP_ADDRESS>1101101     != 0b<IP_ADDRESS>1001001     golden reference is 0b<IP_ADDRESS>1001010
FAIL
0.0018825531005859375     /= -2516                     != -7.5250864028930664062e-07 golden reference is -7.450580596923828125e-07
0b0.0001.10.111011011     /= 0b1.1110.11.001110101     != 0b1.0000001.11.100101     golden reference is 0b1.0000001.11.100100
FAIL
9.96875                   /= 7.662109375               != 1.30078125                golden reference is 1.30126953125

0b<IP_ADDRESS>11111000     /= 0b<IP_ADDRESS>01010011     != 0b<IP_ADDRESS>01101000     golden reference is 0b<IP_ADDRESS>01101001
FAIL
-0.1373291015625          /= 0.610107421875            != -0.22503662109375         golden reference is -0.22509765625

0b<IP_ADDRESS>11001010     /= 0b<IP_ADDRESS>11000011     != 0b<IP_ADDRESS>01100111     golden reference is 0b<IP_ADDRESS>01101000
FAIL
-1.791015625              /= 0.2860107421875           != -6.263671875              golden reference is -6.26171875

0b<IP_ADDRESS>01010100     /= 0b<IP_ADDRESS>00100111     != 0b<IP_ADDRESS>10000111     golden reference is 0b<IP_ADDRESS>10000110
FAIL
-27.765625                /= 2.162109375               != -12.83984375              golden reference is -12.84375

0b<IP_ADDRESS>1110001     /= 0b<IP_ADDRESS>10100110     != 0b<IP_ADDRESS>11010111     golden reference is 0b<IP_ADDRESS>11011000
FAIL
-0.120452880859375        /= -122.5                    != 0.0009822845458984375     golden reference is 0.00098419189453125
0b<IP_ADDRESS>01101011     /= 0b<IP_ADDRESS>0101000     != 0b0.0001.10.000000011     golden reference is 0b0.0001.10.000000100
FAIL
-0.0034027099609375       /= 0.772705078125            != -0.004405975341796875     golden reference is -0.00440216064453125
0b1.0001.11.101111100     /= 0b<IP_ADDRESS>01011101     != 0b<IP_ADDRESS>0000011     golden reference is 0b<IP_ADDRESS>0000010
FAIL
0.000214099884033203125   /= -0.0258026123046875       != -0.00829315185546875      golden reference is -0.00830078125

0b0.00001.11.11000001     /= 0b<IP_ADDRESS>0011011     != 0b<IP_ADDRESS>0111111     golden reference is 0b<IP_ADDRESS>1000000
FAIL
-0.2811279296875          /= -0.13555908203125         != 2.0732421875              golden reference is 2.07421875

0b<IP_ADDRESS>11111111     /= 0b<IP_ADDRESS>10101101     != 0b<IP_ADDRESS>01001011     golden reference is 0b<IP_ADDRESS>01001100
FAIL
7.080078125               /= 0.3287353515625           != 21.546875                 golden reference is 21.53125

0b<IP_ADDRESS>00101001     /= 0b<IP_ADDRESS>10000101     != 0b<IP_ADDRESS>1100011     golden reference is 0b<IP_ADDRESS>1100010
FAIL
10.140625                 /= -0.302001953125           != -33.59375                 golden reference is -33.5625

0b<IP_ADDRESS>00100100     /= 0b<IP_ADDRESS>10101010     != 0b<IP_ADDRESS>0110011     golden reference is 0b<IP_ADDRESS>0110010
FAIL
-1.5869140625             /= 0.06842041015625          != -23.203125                golden reference is -23.1875

0b<IP_ADDRESS>10110010     /= 0b<IP_ADDRESS>11000010     != 0b<IP_ADDRESS>1001101     golden reference is 0b<IP_ADDRESS>1001100
FAIL
314                       /= 0.005863189697265625      != 53632                     golden reference is 53504

0b0.1110.00.001110100     /= 0b<IP_ADDRESS>0000001     != 0b0.11110.11.10100011     golden reference is 0b0.11110.11.10100010
FAIL
-0.039520263671875        /= -0.14569091796875         != 0.2713623046875           golden reference is 0.271240234375

0b<IP_ADDRESS>0001111     /= 0b<IP_ADDRESS>01010011     != 0b<IP_ADDRESS>10101111     golden reference is 0b<IP_ADDRESS>10101110
FAIL
0.7255859375              /= -0.0028839111328125       != -251.5                    golden reference is -251.625

0b<IP_ADDRESS>10011100     /= 0b1.0001.11.011110100     != 0b<IP_ADDRESS>1011100     golden reference is 0b<IP_ADDRESS>1011101
FAIL
-0.051239013671875        /= 22.296875                 != -0.002300262451171875     golden reference is -0.00229644775390625
0b<IP_ADDRESS>0001111     /= 0b<IP_ADDRESS>0010011     != 0b1.0001.11.001011011     golden reference is 0b1.0001.11.001011010
FAIL
3.6796875                 /= 21.71875                  != 0.16937255859375          golden reference is 0.16943359375

0b<IP_ADDRESS>10111000     /= 0b<IP_ADDRESS>1101110     != 0b<IP_ADDRESS>11010111     golden reference is 0b<IP_ADDRESS>11011000
FAIL
-0.01110076904296875      /= -0.9736328125             != 0.01140594482421875       golden reference is 0.0113983154296875
0b<IP_ADDRESS>0101111     /= 0b<IP_ADDRESS>10010100     != 0b<IP_ADDRESS>1010111     golden reference is 0b<IP_ADDRESS>1010110
FAIL
2964                      /= 1.03662109375             != 2856                      golden reference is 2860

0b0.1110.11.011100101     /= 0b<IP_ADDRESS>01001011     != 0b0.1110.11.011001010     golden reference is 0b0.1110.11.011001011
FAIL
-0.00539398193359375      /= 122.125                   != -4.41074371337890625e-05  golden reference is -4.422664642333984375e-05
0b<IP_ADDRESS>0000110     /= 0b<IP_ADDRESS>0100010     != 0b1.00001.01.01110010     golden reference is 0b1.00001.01.01110011
FAIL
-0.311279296875           /= 0.10211181640625          != -3.0478515625             golden reference is -3.048828125

0b<IP_ADDRESS>11110110     /= 0b<IP_ADDRESS>00010010     != 0b<IP_ADDRESS>00110001     golden reference is 0b<IP_ADDRESS>00110010
FAIL
-81.625                   /= 0.777587890625            != -104.9375                 golden reference is -105

0b<IP_ADDRESS>0011010     /= 0b<IP_ADDRESS>01110001     != 0b<IP_ADDRESS>0001111     golden reference is 0b<IP_ADDRESS>0010000
FAIL
38.1875                   /= -1.14501953125            != -33.375                   golden reference is -33.34375

0b<IP_ADDRESS>1000110     /= 0b<IP_ADDRESS>00101001     != 0b<IP_ADDRESS>0101100     golden reference is 0b<IP_ADDRESS>0101011
FAIL
-1.580078125              /= -0.005619049072265625     != 281.5                     golden reference is 281

0b<IP_ADDRESS>10100100     /= 0b<IP_ADDRESS>1000001     != 0b0.1110.00.000110011     golden reference is 0b0.1110.00.000110010
FAIL
-0.1455078125             /= -0.4827880859375          != 0.30126953125             golden reference is 0.3013916015625

0b<IP_ADDRESS>01010000     /= 0b<IP_ADDRESS>01110011     != 0b<IP_ADDRESS>10100100     golden reference is 0b<IP_ADDRESS>10100101
FAIL
0.0171966552734375        /= -2.572265625              != -0.006683349609375        golden reference is -0.006687164306640625
0b<IP_ADDRESS>1100111     /= 0b<IP_ADDRESS>01001010     != 0b<IP_ADDRESS>1011000     golden reference is 0b<IP_ADDRESS>1011001
FAIL
-0.000171184539794921875  /= 3.5849609375              != -4.76837158203125e-05     golden reference is -4.780292510986328125e-05
0b1.00001.11.01100111     /= 0b<IP_ADDRESS>01010111     != 0b1.00001.01.10010000     golden reference is 0b1.00001.01.10010001
FAIL
2.7080078125              /= 1.3017578125              != 2.0810546875              golden reference is 2.080078125

0b<IP_ADDRESS>11010101     /= 0b<IP_ADDRESS>01101010     != 0b<IP_ADDRESS>01010011     golden reference is 0b<IP_ADDRESS>01010010
FAIL
107.5625                  /= -855                      != -0.1258544921875          golden reference is -0.12579345703125
0b<IP_ADDRESS>0111001     /= 0b1.1110.01.101010111     != 0b<IP_ADDRESS>00001110     golden reference is 0b<IP_ADDRESS>00001101
FAIL
2188                      /= 7.87890625                != 278                       golden reference is 277.5

0b0.1110.11.000100011     /= 0b<IP_ADDRESS>11000010     != 0b0.1110.00.000101100     golden reference is 0b0.1110.00.000101011
FAIL
-0.2962646484375          /= -42.375                   != 0.006988525390625         golden reference is 0.006992340087890625
0b<IP_ADDRESS>01111011     /= 0b<IP_ADDRESS>1001100     != 0b<IP_ADDRESS>0101000     golden reference is 0b<IP_ADDRESS>0101001
FAIL
253.625                   /= -112.75                   != -2.25                     golden reference is -2.2490234375

0b<IP_ADDRESS>1101101     /= 0b<IP_ADDRESS>0001100     != 0b<IP_ADDRESS>00000000     golden reference is 0b<IP_ADDRESS>11111111
FAIL
-0.4892578125             /= -2.07421875               != 0.23583984375             golden reference is 0.23590087890625
0b<IP_ADDRESS>10101000     /= 0b<IP_ADDRESS>01001100     != 0b<IP_ADDRESS>00011000     golden reference is 0b<IP_ADDRESS>00011001
FAIL
0.22015380859375          /= 0.105255126953125         != 2.0908203125              golden reference is 2.091796875

0b<IP_ADDRESS>00010111     /= 0b<IP_ADDRESS>01111001     != 0b<IP_ADDRESS>01011101     golden reference is 0b<IP_ADDRESS>01011110
FAIL
-0.8388671875             /= 414.5                     != -0.00202178955078125      golden reference is -0.002025604248046875
0b<IP_ADDRESS>01101100     /= 0b0.1110.00.100111101     != 0b1.0001.11.000010010     golden reference is 0b1.0001.11.000010011
FAIL
8.01953125                /= 0.00038623809814453125    != 20800                     golden reference is 20736

0b<IP_ADDRESS>00000101     /= 0b0.0001.00.100101010     != 0b0.11110.10.01000101     golden reference is 0b0.11110.10.01000100
FAIL
0.1378173828125           /= 209.375                   != 0.00065898895263671875    golden reference is 0.0006580352783203125
0b<IP_ADDRESS>11010010     /= 0b<IP_ADDRESS>0001011     != 0b0.0001.01.010110011     golden reference is 0b0.0001.01.010110010
FAIL
-10.20703125              /= -13216                    != 0.00077152252197265625    golden reference is 0.0007724761962890625
0b<IP_ADDRESS>00110101     /= 0b1.11110.01.10011101     != 0b0.0001.01.100101001     golden reference is 0b0.0001.01.100101010
FAIL
217                       /= -11.671875                != -18.578125                golden reference is -18.59375

0b<IP_ADDRESS>1001000     /= 0b<IP_ADDRESS>10101100     != 0b<IP_ADDRESS>0100101     golden reference is 0b<IP_ADDRESS>0100110
FAIL
15.4296875                /= -1.93017578125            != -7.9921875                golden reference is -7.994140625

0b<IP_ADDRESS>01101110     /= 0b<IP_ADDRESS>01110001     != 0b<IP_ADDRESS>11111100     golden reference is 0b<IP_ADDRESS>11111101
FAIL
-49920                    /= 56.84375                  != -879                      golden reference is -878

0b1.11110.11.10000110     /= 0b<IP_ADDRESS>0011011     != 0b1.1110.01.101101111     golden reference is 0b1.1110.01.101101110
FAIL
-3.29296875               /= -1.78955078125            != 1.83984375                golden reference is 1.84033203125

0b<IP_ADDRESS>00101100     /= 0b<IP_ADDRESS>01010001     != 0b<IP_ADDRESS>10111000     golden reference is 0b<IP_ADDRESS>10111001
FAIL
1.2744140625              /= 116.9375                  != 0.01090240478515625       golden reference is 0.010894775390625
0b<IP_ADDRESS>00110010     /= 0b<IP_ADDRESS>1001111     != 0b<IP_ADDRESS>0010101     golden reference is 0b<IP_ADDRESS>0010100
FAIL
12.0078125                /= -0.00049686431884765625   != -24128                    golden reference is -24192

0b<IP_ADDRESS>00000010     /= 0b1.0001.01.000001001     != 0b1.11110.10.01111001     golden reference is 0b1.11110.10.01111010
FAIL
0.0892333984375           /= 25.859375                 != 0.003448486328125         golden reference is 0.003452301025390625
0b<IP_ADDRESS>01101100     /= 0b<IP_ADDRESS>1110111     != 0b0.0001.11.110001000     golden reference is 0b0.0001.11.110001001
FAIL
2.1755695343017578125e-05 /= 0.24542236328125          != 8.84532928466796875e-05   golden reference is 8.869171142578125e-05
0b0.00001.00.01101101     /= 0b<IP_ADDRESS>10110101     != 0b0.00001.10.01110011     golden reference is 0b0.00001.10.01110100
FAIL
0.053314208984375         /= -0.073333740234375        != -0.726806640625           golden reference is -0.72705078125

0b<IP_ADDRESS>1010011     /= 0b<IP_ADDRESS>01100011     != 0b<IP_ADDRESS>10100001     golden reference is 0b<IP_ADDRESS>10100010
FAIL
-1.5273690223693847656e-07 /= 5.14453125                != -2.9336661100387573242e-08 golden reference is -2.98023223876953125e-08
0b1.0000001.01.010010     /= 0b<IP_ADDRESS>01001010     != 0b1.00000001.10.11111     golden reference is 0b1.00000001.11.00000
FAIL
-0.0052642822265625       /= 2820                      != -1.8626451492309570312e-06 golden reference is -1.8700957298278808594e-06
0b<IP_ADDRESS>1100100     /= 0b0.1110.11.011000001     != 0b1.000001.00.1111010     golden reference is 0b1.000001.00.1111011
FAIL
-8.55922698974609375e-05  /= -72.9375                  != 1.1697411537170410156e-06 golden reference is 1.1771917343139648438e-06
0b1.00001.10.01100111     /= 0b<IP_ADDRESS>0001111     != 0b0.000001.00.0011101     golden reference is 0b0.000001.00.0011110
posit< 16, 2>                                                /=             (native)   FAIL 54 failed test cases
0b0.000000000001.01.0 / 0b0.000000000001.00.1 = 0b<IP_ADDRESS>10101010
1.13687e-13 / 8.52651e-14 = 1.33301
0b0.000000000001.01.0 / 0b0.000000000001.00.1 = 0b<IP_ADDRESS>10101011
1.13687e-13 / 8.52651e-14 = 1.3335
FAIL
Fast specialization posit<16,2>: FAIL

It appears that the bitNPlusOne calculation is not correct, and causing these failures, but how to fix it is stumping me.

@davidmallasen @RaulMurillo finally, got it figured out. we now have a fast posit<16,2>
Fast specialization posit<16,2>: results only
 posit< 16,2> useed scale     4     minpos scale        -56     maxpos scale         56  :  0

Exhaustive tests
posit< 16, 2>                                                div            (native)   PASS
posit< 16, 2>                                                mul            (native)   PASS
posit< 16, 2>                                                sub            (native)   PASS
posit< 16, 2>                                                add            (native)   PASS

Fast specialization posit<16,2>: results only
 posit< 16,2> useed scale     4     minpos scale        -56     maxpos scale         56  :  0

Special case tests
posit< 16, 2> Initialize to zero:            PASS
posit< 16, 2> Initialize to NAN              PASS
posit< 16, 2> Initialize to INFINITY         PASS
posit< 16, 2> sign is true                   PASS
posit< 16, 2> is negative                    PASS
posit< 16, 2> sign is false                  PASS
posit< 16, 2> is positive                    PASS
posit< 16, 2>                                                addition       PASS
posit< 16, 2>                                                subtraction    PASS
posit< 16, 2>                                                multiplication PASS
posit< 16, 2>                                                division       PASS
Logic operator tests
posit< 16, 2>                                                    ==         (native)   PASS
posit< 16, 2>                                                    !=         (native)   PASS
posit< 16, 2>                                                    <          (native)   PASS
posit< 16, 2>                                                    <=         (native)   PASS
posit< 16, 2>                                                    >          (native)   PASS
posit< 16, 2>                                                    >=         (native)   PASS
Assignment/conversion tests
posit< 16, 2>                                                integer assign (native)   PASS
Arithmetic tests 1048576 randoms each
posit< 16, 2>                                                addition       (native)   PASS
posit< 16, 2>                                                +=             (native)   PASS
posit< 16, 2>                                                subtraction    (native)   PASS
posit< 16, 2>                                                -=             (native)   PASS
posit< 16, 2>                                                multiplication (native)   PASS
posit< 16, 2>                                                *=             (native)   PASS
posit< 16, 2>                                                division       (native)   PASS
posit< 16, 2>                                                /=             (native)   PASS
Elementary function tests
posit< 16, 2>                                                sqrt           (native)   PASS
posit< 16, 2>                                                exp                       PASS
posit< 16, 2>                                                exp2                      PASS
posit< 16, 2>                                                log                       PASS
posit< 16, 2>                                                log2                      PASS
posit< 16, 2>                                                log10                     PASS
posit< 16, 2>                                                sin                       PASS
posit< 16, 2>                                                cos                       PASS
posit< 16, 2>                                                tan                       PASS
posit< 16, 2>                                                asin                      PASS
posit< 16, 2>                                                acos                      PASS
posit< 16, 2>                                                atan                      PASS
posit< 16, 2>                                                sinh                      PASS
posit< 16, 2>                                                cosh                      PASS
posit< 16, 2>                                                tanh                      PASS
posit< 16, 2>                                                asinh                     PASS
posit< 16, 2>                                                acosh                     PASS
posit< 16, 2>                                                atanh                     PASS
VerifyPower has been truncated
posit< 16, 2>                                                pow                       PASS
Fast specialization posit<16,2>: PASS

Hello @Ravenwater . Great news, thanks for debugging that! I've been out of office for a couple of weeks but I'll check this soon to corroborate that it's also working on our end. In the end did you use the posit oracle to check the bit patterns or was that too slow?

@davidmallasen the posit oracle was very useful in debugging and generating hypotheses. Fundamentally, I had to reverse-engineer the algorithm that John and Cerlean had created. They created algorithms for es=0,1, and 2, and these take different shortcut to encode/decode, and round. The debugging allowed me to rediscover that (it has been 5 years since I wrote any of the posit code). Once I knew what was going on, I realized that the rounding was using the shortcuts/interpretation of the es=1 algorithm, and thus I needed to rip and replace it with the es=2 algorithms.
Given the amount of time I spent on this, you better use this type, :-)

Thanks for the info and for all of the time you put into this @Ravenwater . We definitely will be using this, since with initial tests it improves performance by around 2.5x. However, with the application I have the results are not the same than with the non-specialized posit<16,2>, although they are similar. I'll try to check why this is happening, but if the exhaustive tests are succeeding it might be some bit-level difference between the non-specialized and the specialized algorithms.

The verification of both implementations happens with the same test, which follows posit arithmetic rules. If there is something inconsistent, the most likely place to look would be the special cases, NaR, NaN assignment, divide by zero.
Now that we have the posito environment, I can set up an exhaustive test between the two and let it run for a day.

Perfect! Using the posito environment would definitely be helpful to see where the two diverge.
Looking again at the code, I'm not sure what the is_power_of_2 function is doing. Also, should we have to revise the integer_assign and float_assign functions?


style: format src/for-redux-swr

Codecov Report

Merging #35 (630f2cf) into main (b901c37) will not change coverage.
The diff coverage is n/a.

@@           Coverage Diff           @@
##             main      #35   +/-   ##
=======================================
  Coverage   99.69%   99.69%
=======================================
  Files          21       21
  Lines         324      324
  Branches       35       35
=======================================
  Hits          323      323
  Misses          1        1

Flag
Coverage Δ

root
99.69% <ø> (ø)

Flags with carried forward coverage won't be shown. Click here to find out more.

Impacted Files
Coverage Δ

src/for-redux-swr/SpreadoSetupImpl.ts
100.00% <ø> (ø)

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update b901c37...630f2cf. Read the comment docs.


Added Contritutor page in HelpOps-Hub

@mdazfar2  we added contributor page in HelpOps-Hub
please take look
fix #60

@mdazfar2  Kindly Assign Me .

@mdazfar2 please assign me


ttu/ruuvitag_sensor data format 3 development

I installed ruuvitag_sensor and RuuviTag-logger and noticed logger cannot handle format 3 data yet.

data_format_3.diff.zip


The form.validate() function only validates the first field

Thanks a lot for this library!
It is allowing handling forms really easy in the Svelte app I'm working on :)
But, I'm having an issue. Basically it is with section Trigger Form Validation, when I call:
// Trigger validation of all fields
form.validate();

Only the first field get validated, instead of validating all fields (expected behavior).
Can you check if that is the case, or am I doing something wrong?
Thanks again, great job here!

Sorry, it was my bad, the library is working nicely.
I was providing an initial value, but not binding it properly to the input...
Thanks!

@lmgonzalves no worries, thanks for closing of the ticket.


de-optimize Repeat

TODO: Notes on Repeat

Coverage increased (+0.2%) to 63.973% when pulling cca9b3fe2fa0ffe269b753a5c19b197061ecaeac on 384fix into 3dc37840f84e479da7acf4f6618f39e6755a4bdd on master.


react-router-redux not triggering handleLocationChange from push action

I am trying to get to the bottom as to why a push action is not getting triggered from a push action, I am using<EMAIL_ADDRESS>and I am doing the render on the server:
const store = configureStore({ router: { location: req.url } }, createMemoryHistory());

  const context: any = { store };

  store.dispatch(push(req.url));

  const app = (
    <Provider store={store}>
      <StaticRouter location={req.url} context={context}>
        <Application />
      </StaticRouter>
    </Provider>
  );

My client code looks like this:
import createHistory from 'history/createBrowserHistory';
import * as React from 'react';

export interface AppProps {
  store: Store<State>;
}

export class App extends React.Component<AppProps> {
  render() {
    const { store } = this.props;

    return (
      <>
        <Helmet>
          <title>PVG Online</title>
        </Helmet>
        <Provider store={store}>
          <ConnectedRouter history={createHistory()}>
            <Application />
          </ConnectedRouter>
        </Provider>
      </>
    );
  }
}

The same code works on a bundled browser only version.
What reason would there be for that to happen or can anyone give me any pointers as to why this would happen.
handleLocationChange but the middleware does the history.push but as the code never makes it to the reducer, a re-render does not happen.

RRR is deprecated.

OK but for anyone else with this problem I had 2 different history objects that was causing the problem.
I was passing a new instance into the router middleware and creating a new instance for the ConnectedRouter.
That is a real pity this is being deprecated, it is extremely useful and nice to isolate the side effect in an action.


negative duration times

in 2020 only, there are about 2,000 rides with negative duration time entries....

after re-checking the original data in neg_dur.R it seems that the original data have the start time after the end time

resolved in #12 by doing solution number 2 above


Could not find module OrderedSet for target x86_64-apple-ios-simulator

[x] I have read the Get Started - Installation section
[x] I have read and done the Get Started - Setup Android section
[x] I have read and done the Get Started - Setup iOS section
[x] I have already searched for the same problem

Environment

Technology
Version

Flutter version
2.3.0-12.1-pre

Plugin version
5.3.2

Android version

iOS version
14.5

Xcode version
12.5

Device information:
Description
Expected behavior:
I would see a normal build
Current behavior:

Steps to reproduce
I'm on MAC MINI M1
Create a new flutter project, add your dependencies run with xcode : boom.

Create new flutter project
Add flutter_inappwebview: ^5.3.2
flutter pub get && cd ios && pod install
Open IOs fplder with Xcode and run

Note that, the podfile.lock seems to be ok :
 - flutter_inappwebview (0.0.1):
    - Flutter
    - flutter_inappwebview/Core (= 0.0.1)
    - OrderedSet (~> 5.0)
  - flutter_inappwebview/Core (0.0.1):
    - Flutter
    - OrderedSet (~> 5.0)

Images
Default flutter project settings in xcode :

Stacktrace/Logcat

Seems to work when launching Xcode with Rosetta...
I didn't determine if it's a flutter issue or a flutter_inappwebview issue.

I face the same issue after upgrade flutter to v2.2.0

?

I have the same problem. Works with XCode with Rosetta but performance is degraded.


How to fetch the historical Data

is there any method for fetching the historical data from NSE till current date ?

Refer to
https://nsepy.xyz/

try this by installing nsepy
import nsepy as ns
import datetime as dt
stocks=['SBIN','AXISBANK','ICICIBANK','HDFCBANK']
start=dt.datetime.today()-dt.timedelta(30)
end=dt.datetime.today()
cl_price={}
cl_price
for ticker in stocks:
cl_price[ticker]=get_history(ticker,start,end) ['Close']     (#to get data of close price only)
cl_price
df=pd.DataFrame.from_dict(cl_price)                                     (#TO CHANGE DICT DATATYPE TO DATAFRAME)

if u want FULL OHLCV data then just remove ['Close']
import nsepy as ns
import datetime as dt
stocks=['SBIN','AXISBANK','ICICIBANK','HDFCBANK']
start=dt.datetime.today()-dt.timedelta(30)
end=dt.datetime.today()
OHLC={}
OHLC
for ticker in stocks:
OHLC[ticker]=get_history(ticker,start,end)


Can inference be run on consumer hardware?

AMD? CPU? Single GPU?
Is this all possible via FastChat?

@GrahamboJangles It is already in FastChat. https://github.com/lm-sys/FastChat#longchat
We currently test it in A100 single GPU and it works pretty well. We are adding more support to let it run more efficiently. Let me know whether it works for your hardware, and we can improve the system support!

@DachengLi1 I have 2 RX6800s, I'm guessing that they are not yet supported?

Regarding RX Series, please see the discussion here. The inference is backed by FastChat, and it seems people can AMD card working. Can you run (there is no load-8-bit yet):
python3 -m fastchat.serve.cli --model-path lmsys/longchat-7b-16k
and let me know if it works for you? Also feel free to submit an issue in FastChat regarding this.
@GrahamboJangles

@DachengLi1 thank you for your help and quick responses.
I ran that command and this was the output:
python -m fastchat.serve.cli --model-path longchat-7b-16k
Traceback (most recent call last):
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\transformers\utils\import_utils.py", line 1146, in _get_module
    return importlib.import_module("." + module_name, self.__name__)
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\importlib\__init__.py", line 126, in import_module
    return _bootstrap._gcd_import(name[level:], package, level)
  File "<frozen importlib._bootstrap>", line 1050, in _gcd_import
  File "<frozen importlib._bootstrap>", line 1027, in _find_and_load
  File "<frozen importlib._bootstrap>", line 1006, in _find_and_load_unlocked
  File "<frozen importlib._bootstrap>", line 688, in _load_unlocked
  File "<frozen importlib._bootstrap_external>", line 883, in exec_module
  File "<frozen importlib._bootstrap>", line 241, in _call_with_frames_removed
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\transformers\models\llama\modeling_llama.py", line 31, in <module>
    from ...modeling_utils import PreTrainedModel
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\transformers\modeling_utils.py", line 83, in <module>
    from accelerate import __version__ as accelerate_version
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\accelerate\__init__.py", line 7, in <module>
    from .accelerator import Accelerator
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\accelerate\accelerator.py", line 33, in <module>
    from .tracking import LOGGER_TYPE_TO_CLASS, GeneralTracker, filter_trackers
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\accelerate\tracking.py", line 45, in <module>
    import wandb
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\wandb\__init__.py", line 26, in <module>
    from wandb import sdk as wandb_sdk
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\wandb\sdk\__init__.py", line 5, in <module>
    from . import wandb_helper as helper  # noqa: F401
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\wandb\sdk\wandb_helper.py", line 6, in <module>
    from .lib import config_util
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\wandb\sdk\lib\config_util.py", line 7, in <module>
    from wandb.util import load_yaml
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\wandb\util.py", line 52, in <module>
    import sentry_sdk  # type: ignore
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\sentry_sdk\__init__.py", line 1, in <module>
    from sentry_sdk.hub import Hub, init
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\sentry_sdk\hub.py", line 8, in <module>
    from sentry_sdk.scope import Scope
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\sentry_sdk\scope.py", line 7, in <module>
    from sentry_sdk.utils import logger, capture_internal_exceptions
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\sentry_sdk\utils.py", line 887, in <module>
    HAS_REAL_CONTEXTVARS, ContextVar = _get_contextvars()
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\sentry_sdk\utils.py", line 857, in _get_contextvars
    if not _is_contextvars_broken():
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\sentry_sdk\utils.py", line 791, in _is_contextvars_broken
    import gevent  # type: ignore
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\gevent\__init__.py", line 86, in <module>
    from gevent._hub_local import get_hub
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\gevent\_hub_local.py", line 101, in <module>
    import_c_accel(globals(), 'gevent.__hub_local')
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\gevent\_util.py", line 148, in import_c_accel
    mod = importlib.import_module(cname)
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\importlib\__init__.py", line 126, in import_module
    return _bootstrap._gcd_import(name[level:], package, level)
  File "src\\gevent\\_hub_local.py", line 1, in init gevent._gevent_c_hub_local
ValueError: greenlet.greenlet size changed, may indicate binary incompatibility. Expected 160 from C header, got 40 from PyObject

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\runpy.py", line 196, in _run_module_as_main
    return _run_code(code, main_globals, None,
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\runpy.py", line 86, in _run_code
    exec(code, run_globals)
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\fastchat\serve\cli.py", line 26, in <module>
    from fastchat.model.model_adapter import add_model_args
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\fastchat\model\__init__.py", line 1, in <module>
    from fastchat.model.model_adapter import (
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\fastchat\model\model_adapter.py", line 16, in <module>
    from transformers import (
  File "<frozen importlib._bootstrap>", line 1075, in _handle_fromlist
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\transformers\utils\import_utils.py", line 1137, in __getattr__
    value = getattr(module, name)
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\transformers\utils\import_utils.py", line 1136, in __getattr__
    module = self._get_module(self._class_to_module[name])
  File "E:\Coding_and_Scripting\Pyhon3.10.4\lib\site-packages\transformers\utils\import_utils.py", line 1148, in _get_module
    raise RuntimeError(
RuntimeError: Failed to import transformers.models.llama.modeling_llama because of the following error (look up to see its traceback):
greenlet.greenlet size changed, may indicate binary incompatibility. Expected 160 from C header, got 40 from PyObject

@GrahamboJangles Thanks for trying it out! Can you submit this to FastChat system? I will also ask the FastChat team to look into it there.

@DachengLi1 Absolutely! Thanks again for your help.

@sejalchopra97 For now you can run 9k tokens with flash attention support (but that does not support kv cache so it will be slow). We just got a member working on it on the vLLM side, once she got it done, we can update here. @LiuXiaoxuanPKU, let me know if you have any suggestion!


fsm: GetState and SetState via applying build to a Stater type

This commit adds a new Stater interface which is a type that is included during a Builder.Build. Build will use Stater's SetState to set the resulting state after a Transition. Also, Build uses the Stater's GetState to set the initial state for the FSM.
Also, this commit introduces Stater as an argument to all handler callback functions so that the Stater can be acted upon or have other serialized components of a Transition type be persisted as well.

Spoke about this and @sean- shared an alternative on call. Going to close this for now.


proposal: prependLeft(), prependRight(), appendLeft(), appendRight()

Motivation
There is a gap in the magic-string API that insertLeft() and insertRight() cannot accommodate.
Proposal
New methods:

s.prependLeft( index, content )

s.appendRight( index, content )

Synonyms for existing methods for naming consistency:

s.appendLeft( index, content )

appendLeft is a synonym for insertLeft

s.prependRight( index, content )

prependRight is a synonym for insertRight

Illustrative example:
var s = new MagicString('0123456789');

s.insertLeft(5, 'A');
s.insertRight(5, 'a');
s.insertRight(5, 'b');
s.insertLeft(5, 'B');
s.insertLeft(5, 'C');
s.insertRight(5, 'c');

// s === '01234ABCcba56789'
console.log(s.toString());

console.log('left  of 5:', s.slice(0, 5));
// left  of 5: 01234ABC

console.log('right of 5:', s.slice(5));
// right of 5: cba56789

//
// Proposed methods
//

s.prependLeft(5, '<');
s.prependLeft(5, '{');
// s === '01234{<ABCcba56789'

s.appendRight(5, '>');
s.appendRight(5, '}');
// s === '01234{<ABCcba>}56789'

s.appendLeft(5, '(');   // appendLeft is a synonym for insertLeft
s.appendLeft(5, '[');   // appendLeft is a synonym for insertLeft
// s === '01234{<ABC([cba>}56789'

s.prependRight(5, ')'); // prependRight is a synonym for insertRight
s.prependRight(5, ']'); // prependRight is a synonym for insertRight
// s === '01234{<ABC([])cba>}56789'

console.log('left  of 5:', s.slice(0, 5));
// left  of 5: '01234{<ABC(['

console.log('right of 5:', s.slice(5));
// right of 5: '])cba>}56789'

Agreed that more control over these types of inserts would be nice. The decaffeinate project extensively uses magic-string, and many of the bugs I've worked through have been due to subtleties where code snippets are inserted in the wrong order due to the details of how magic-string works. (Not that magic-string is necessarily at fault; it's a hard problem, especially in situations where you need to do many inserts at the same point.)
Here are the rules I've learned to follow when working on decaffeinate:

Always use insertLeft. This ensures that if you insert multiple things in order at the same point, they will appear in order instead of in reverse order. This is a good justification for the existence of appendRight. One problem with this is when you try to perform modifications to code, then get that code to move it elsewhere. For example, if you wrap an expression in parens and then call slice to get its code, the insertLeft means that you'll miss the open-paren. I ended up writing a patchAndGetCode method to work around this limitation.
As much as possible, make it so code patching happens in order. For example, if you want to wrap an expression in parens and transform it, insert the left paren, then do the transform, then insert the right paren.
Split work up into multiple passes when possible. For example, CoffeeScript code can have a lot of "implicit" parens for function calls, and a number of magic-string-related problems were solved by inserting those parens in a separate CoffeeScript to CoffeeScript step before the main transformation.

I've thought a bit about how the magic-string API might be changed to alleviate these problems. One thought I've had is that you could provide a priority number (or some better name) that determines the absolute order of the insert. Negative means before the index (like insertLeft) and positive means after the index (like insertRight). For example, you might put an open-paren at priority 50 and unary negation at priority 100, and then regardless of insertion order, you'd get (-.
Another nice feature would be a way to programmatically examine the fragments that have been inserted at a particular point, and insert and slice between any of those fragments.
But really, while these features would make more advanced use cases possible, it seems like the type of code that uses them may end up not being very pleasant or robust. One interpretation is that magic-string, and any tool with its strategy, naturally gets pretty fragile when doing complicated enough work, and it may be better at larger scales to use a tool like recast where you work on an AST rather than doing string modifications. The decaffeinate project is relatively stable at this point with the practices I mentioned above, so it's unlikely to have to move away from magic-string or to use more advanced features if they were introduced.

I agree with the proposal to add those methods. I had a feeling something like this might be necessary, but I wanted to see how far we could get with insertLeft and insertRight before needing to add extra API complexity. It looks like we've reached that point with Bublé and Decaffeinate.
I'm hoping that using these new methods in Bublé would fix #111 – it sounds like maybe the erroneously removed code is a casualty of using insertLeft and insertRight to hack around the limitations described above.
I can see how priority-based system such as @alangpierce describes might in theory be necessary. For now though I think we should stick with (ap|pre)pend(Left|Right) – much simpler to implement, and probably addresses 99% of use cases.


Add toggle to disable the internal wifi chip

See: https://github.com/AmberELEC/AmberELEC/pull/844 for the implementation of the batocera-internal-wifi script.


Add support for 'as' and 'from' in import statement

It should be possible to use 'as' and 'from' when importing a macro file, like it's possible in Twig and Jinja2. This would mitigate name collisions and improve compatibility with Twig and Jinja2.
Example with 'as' in import statement for setting an alias for the imported file:
{% import 'forms.html' as forms %}
{{ forms.input('name') }}

Example with 'from' in import statement for importing named macros:
{% from 'forms.html' import input as input_text, textarea %}
{{ input_text('street') }}
{{ textarea('comment') }}

Resolved via #271


BugFix: Room member details: only the "start chat" text is clickable,…

… not that whole button area.
https://github.com/vector-im/vector-ios/issues/282

LGTM


Fix devtools popup inspection

Seems that this got broken recently. It checks if Root (Application) is a TopLevel which could never work. Instead we have to get the hovered TopLevel and try to find its "root" TopLevel (which is the root Window on desktop).

You can test this PR using the following package version. 0.10.999-cibuild0019582-beta. (feed url: https://nuget.avaloniaui.net/repository/avalonia-all/index.json) [PRBUILDID]

You can test this PR using the following package version. 0.10.999-cibuild0019607-beta. (feed url: https://nuget.avaloniaui.net/repository/avalonia-all/index.json) [PRBUILDID]


Update truststores/keystores to pekko-remote

resolves issue #203

Regenerate the keystore/truststore for remote tests
I've followed the guide at https://www.digicert.com/kb/ssl-support/openssl-quick-reference-guide.htm to update the makefile's domain.csr recipe. I then ran 'make' and deleted any files that were not there previously (i.e. the private key)

Regenerate the keystore/truststore for stream-tests
I used the same truststore/keyspace as remote-tests here.

Update CN=akka-remote to pekko-remote to reflect new test cert

Why do we validatePullRequest with Java 8 environment but do nightly builds / nightly aeron test with Java 11?

X509ReadersSpec: Test passing locally:
[info] X509ReadersSpec:
[info] X509Readers
[info] - must read a certificate's name from the CN (82 milliseconds)
[info] - must read both the CN and the subject alternative names (4 milliseconds)
[info] - must read a certificate that has no SAN extension (1 millisecond)
[info] Run completed in 1 second, 182 milliseconds.
[info] Total number of tests run: 3
[info] Suites: completed 1, aborted 0
[info] Tests: succeeded 3, failed 0, canceled 0, ignored 0, pending 0
[info] All tests passed.
[success] Total time: 41 s, completed Apr 27, 2023 10:56:50 AM


Make type-hint tag

@TizzySaurus
Closes python-discord/meta#154
Let the bikeshedding begin!

@SavagePastaMan
A few first-glance alterations:
I don't like that we're calling the variable sum, thus overriding the built-in sum() function. The type hint here also doesn't particularly make sense. Inline assignment type hints like this should only be done when the type isn't obvious from the variables / other type hints.
There's also some small rewording I've done here.
Current proposal:

We should probably link to some further resources on type hints (perhaps a PEP?) and also mention static type checkers like mypy which can be used to "enforce" type hints.
I'm going to bed now, will look further into this tomorrow :+1:
*(Apparently my tired brain forgot to add the labels all at once so sorry for the spam there.)

The type hint here also doesn't particularly make sense.

I wanted to include it to show that you can typehints normal variables too, maybe we can find another place to show that? I agree with not naming it sum though.

We should probably link to some further resources on type hints (perhaps a PEP?) and also mention static type checkers like mypy which can be used to "enforce" type hints.

Yes, I agree.
@TizzySaurus

@jonathan-d-zhang are you interested in continuing this? If not i'd be happy to take over.

@wookie184 oops, I kinda forgot about this yeah, you can take over if you'd like

I've made a couple of changes, feel free to request changes on any of them if you think anything should be reverted to previous wording or changed further


Change the dev URL port number according to docz

Just a minor fix.
Port mentioned in Contribution guide is 3000 while it's running at 5000.  Port number is updated in this PR.

Oops sorry about this!

Thank you !!

Thanks, @SaraVieira for accepting my PR. :)
Looking forward to contributing more on this repo.

By the way, I am new to open source & I started my journey 3 days back with my first PR at Mozilla's repo.
I am working on Node & React these days. I am looking for opensource projects in this area.
@SaraVieira & @gaearon I would appreciate if you guys recommend me some good opensource projects which are beginner friendly.
Thanks.


Ship to Brew

For nicer usage on Mac OS ship to Brew.

This should be checked later. Currently I don't see demand.


Update to 0.2.0-SNAPSHOT and cudf-0.15-SNAPSHOT

This is another attempt at #251 using my public fork.  It updates the versions on branch-0.2 to use 0.2.0-SNAPSHOT for the plugin and 0.15-SNAPSHOT for cudf.

Going to merge this as CI is not set up yet, but we need to move forward.  Users can still build cudf-0.15-snapshot themselves


Update screenshot showing service create

What's wrong?
(be specific, screenshots or a copy/paste of the affected part of the page is useful)
The screenshot for creating a service is outdated because it shows the old summary section on the right hand side (it also shows elasticsearch rather than opensearch).

URL of affected page, and any other information
URL: https://developer.aiven.io/docs/platform/howto/create_new_service.html

https://github.com/aiven/devportal/pull/490 created as a fix.

Fixed on #490